53df9fcc3b3f7fae225a419672afcb7d380f7292
[WebKit-https.git] / Source / WebCore / bindings / scripts / CodeGeneratorV8.pm
1 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
2 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
3 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
4 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
5 # Copyright (C) 2006 Apple Computer, Inc.
6 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
7 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
8 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
9 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
10 #
11 # This library is free software; you can redistribute it and/or
12 # modify it under the terms of the GNU Library General Public
13 # License as published by the Free Software Foundation; either
14 # version 2 of the License, or (at your option) any later version.
15 #
16 # This library is distributed in the hope that it will be useful,
17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 # Library General Public License for more details.
20 #
21 # You should have received a copy of the GNU Library General Public License
22 # along with this library; see the file COPYING.LIB.  If not, write to
23 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 # Boston, MA 02111-1307, USA.
25 #
26
27 package CodeGeneratorV8;
28
29 use strict;
30
31 use Digest::MD5;
32
33 use constant FileNamePrefix => "V8";
34
35 my $codeGenerator;
36
37 my $module = "";
38 my $outputDir = "";
39 my $outputHeadersDir = "";
40
41 my @headerContent = ();
42 my @implContentHeader = ();
43 my @implFixedHeader = ();
44 my @implContent = ();
45 my @implContentDecls = ();
46 my %implIncludes = ();
47 my %headerIncludes = ();
48
49 my @allParents = ();
50
51 # Default .h template
52 my $headerTemplate = << "EOF";
53 /*
54     This file is part of the WebKit open source project.
55     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
56
57     This library is free software; you can redistribute it and/or
58     modify it under the terms of the GNU Library General Public
59     License as published by the Free Software Foundation; either
60     version 2 of the License, or (at your option) any later version.
61
62     This library is distributed in the hope that it will be useful,
63     but WITHOUT ANY WARRANTY; without even the implied warranty of
64     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
65     Library General Public License for more details.
66
67     You should have received a copy of the GNU Library General Public License
68     along with this library; see the file COPYING.LIB.  If not, write to
69     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
70     Boston, MA 02111-1307, USA.
71 */
72 EOF
73
74 # Default constructor
75 sub new
76 {
77     my $object = shift;
78     my $reference = { };
79
80     $codeGenerator = shift;
81     $outputDir = shift;
82     $outputHeadersDir = shift;
83
84     bless($reference, $object);
85     return $reference;
86 }
87
88 # Params: 'domClass' struct
89 sub GenerateInterface
90 {
91     my $object = shift;
92     my $dataNode = shift;
93     my $defines = shift;
94
95     # Start actual generation
96     if ($dataNode->extendedAttributes->{"Callback"}) {
97         $object->GenerateCallbackHeader($dataNode);
98         $object->GenerateCallbackImplementation($dataNode);
99     } else {
100         $object->GenerateHeader($dataNode);
101         $object->GenerateImplementation($dataNode);
102     }
103
104     $object->WriteData($dataNode);
105 }
106
107 # Params: 'idlDocument' struct
108 sub GenerateModule
109 {
110     my $object = shift;
111     my $dataNode = shift;
112
113     $module = $dataNode->module;
114 }
115
116 sub AddToImplIncludes
117 {
118     my $header = shift;
119     my $conditional = shift;
120
121     if (not $conditional) {
122         $implIncludes{$header} = 1;
123     } elsif (not exists($implIncludes{$header})) {
124         $implIncludes{$header} = $conditional;
125     } else {
126         my $oldValue = $implIncludes{$header};
127         if ($oldValue ne 1) {
128             my %newValue = ();
129             $newValue{$conditional} = 1;
130             foreach my $condition (split(/\|/, $oldValue)) {
131                 $newValue{$condition} = 1;
132             }
133             $implIncludes{$header} = join("|", sort keys %newValue);
134         }
135     }
136 }
137
138 sub AddIncludesForType
139 {
140     my $type = $codeGenerator->StripModule(shift);
141
142     # When we're finished with the one-file-per-class
143     # reorganization, we won't need these special cases.
144     if (IsTypedArrayType($type)) {
145         AddToImplIncludes("wtf/${type}.h");
146     }
147     if (!$codeGenerator->IsPrimitiveType($type) and !$codeGenerator->IsStringType($type) and !$codeGenerator->AvoidInclusionOfType($type) and $type ne "Date") {
148         # default, include the same named file
149         AddToImplIncludes(GetV8HeaderName(${type}));
150
151         if ($type =~ /SVGPathSeg/) {
152             my $joinedName = $type;
153             $joinedName =~ s/Abs|Rel//;
154             AddToImplIncludes("${joinedName}.h");
155         }
156     }
157
158     # additional includes (things needed to compile the bindings but not the header)
159
160     if ($type eq "CanvasRenderingContext2D") {
161         AddToImplIncludes("CanvasGradient.h");
162         AddToImplIncludes("CanvasPattern.h");
163         AddToImplIncludes("CanvasStyle.h");
164     }
165
166     if ($type eq "CanvasGradient" or $type eq "XPathNSResolver") {
167         AddToImplIncludes("PlatformString.h");
168     }
169
170     if ($type eq "CSSStyleSheet" or $type eq "StyleSheet") {
171         AddToImplIncludes("CSSImportRule.h");
172     }
173
174     if ($type eq "CSSStyleDeclaration") {
175         AddToImplIncludes("StylePropertySet.h");
176     }
177
178     if ($type eq "Plugin" or $type eq "PluginArray" or $type eq "MimeTypeArray") {
179         # So we can get String -> AtomicString conversion for namedItem().
180         AddToImplIncludes("wtf/text/AtomicString.h");
181     }
182 }
183
184 sub GenerateConditionalString
185 {
186     my $node = shift;
187     my $conditional = $node->extendedAttributes->{"Conditional"};
188     if ($conditional) {
189         return $codeGenerator->GenerateConditionalStringFromAttributeValue($conditional);
190     } else {
191         return "";
192     }
193 }
194
195 sub GetSVGPropertyTypes
196 {
197     my $implType = shift;
198
199     my $svgPropertyType;
200     my $svgListPropertyType;
201     my $svgNativeType;
202
203     return ($svgPropertyType, $svgListPropertyType, $svgNativeType) if not $implType =~ /SVG/;
204
205     $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($implType);
206     return ($svgPropertyType, $svgListPropertyType, $svgNativeType) if not $svgNativeType;
207
208     # Append space to avoid compilation errors when using  PassRefPtr<$svgNativeType>
209     $svgNativeType = "$svgNativeType ";
210
211     my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implType);
212     if ($svgNativeType =~ /SVGPropertyTearOff/) {
213         $svgPropertyType = $svgWrappedNativeType;
214         AddToImplIncludes("SVGAnimatedPropertyTearOff.h");
215     } elsif ($svgNativeType =~ /SVGListPropertyTearOff/ or $svgNativeType =~ /SVGStaticListPropertyTearOff/) {
216         $svgListPropertyType = $svgWrappedNativeType;
217         $headerIncludes{"SVGAnimatedListPropertyTearOff.h"} = 1;
218         $headerIncludes{"SVGStaticListPropertyTearOff.h"} = 1;
219     } elsif ($svgNativeType =~ /SVGTransformListPropertyTearOff/) {
220         $svgListPropertyType = $svgWrappedNativeType;
221         $headerIncludes{"SVGAnimatedListPropertyTearOff.h"} = 1;
222         $headerIncludes{"SVGTransformListPropertyTearOff.h"} = 1;
223     } elsif ($svgNativeType =~ /SVGPathSegListPropertyTearOff/) {
224         $svgListPropertyType = $svgWrappedNativeType;
225         $headerIncludes{"SVGPathSegListPropertyTearOff.h"} = 1;
226     }
227
228     if ($svgPropertyType) {
229         $svgPropertyType = "SVGPoint" if $svgPropertyType eq "FloatPoint";
230     }
231
232     return ($svgPropertyType, $svgListPropertyType, $svgNativeType);
233 }
234
235 sub GenerateHeader
236 {
237     my $object = shift;
238     my $dataNode = shift;
239
240     my $interfaceName = $dataNode->name;
241     my $className = "V8$interfaceName";
242     my $implClassName = $interfaceName;
243
244     # Copy contents of parent classes except the first parent or if it is
245     # EventTarget.
246     $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@allParents, 1);
247     $codeGenerator->LinkOverloadedFunctions($dataNode);
248
249     my $hasDependentLifetime = $dataNode->extendedAttributes->{"V8DependentLifetime"} || $dataNode->extendedAttributes->{"ActiveDOMObject"} || $className =~ /SVG/;
250     if (!$hasDependentLifetime) {
251         foreach (@{$dataNode->parents}) {
252             my $parent = $codeGenerator->StripModule($_);
253             next if $parent eq "EventTarget";
254             $headerIncludes{"V8${parent}.h"} = 1;
255         }
256     }
257
258     # - Add default header template
259     push(@headerContent, GenerateHeaderContentHeader($dataNode));
260
261     $headerIncludes{"wtf/text/StringHash.h"} = 1;
262     $headerIncludes{"WrapperTypeInfo.h"} = 1;
263     $headerIncludes{"V8DOMWrapper.h"} = 1;
264     $headerIncludes{"wtf/HashMap.h"} = 1;
265     $headerIncludes{"v8.h"} = 1;
266
267     my $headerClassInclude = GetHeaderClassInclude($implClassName);
268     $headerIncludes{$headerClassInclude} = 1 if $headerClassInclude ne "";
269
270     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($implClassName);
271
272     foreach my $headerInclude (sort keys(%headerIncludes)) {
273         if ($headerInclude =~ /wtf|v8\.h/) {
274             push(@headerContent, "#include \<${headerInclude}\>\n");
275         } else {
276             push(@headerContent, "#include \"${headerInclude}\"\n");
277         }
278     }
279
280     push(@headerContent, "\nnamespace WebCore {\n");
281     push(@headerContent, "\ntemplate<typename PropertyType> class SVGPropertyTearOff;\n") if $svgPropertyType;
282     if ($svgNativeType) {
283         if ($svgNativeType =~ /SVGStaticListPropertyTearOff/) {
284             push(@headerContent, "\ntemplate<typename PropertyType> class SVGStaticListPropertyTearOff;\n");
285         } else {
286             push(@headerContent, "\ntemplate<typename PropertyType> class SVGListPropertyTearOff;\n");
287         }
288     }
289
290     push(@headerContent, "\n");
291     push(@headerContent, "class FloatRect;\n") if $svgPropertyType && $svgPropertyType eq "FloatRect";
292     push(@headerContent, "class Dictionary;\n") if IsConstructorTemplate($dataNode, "Event");
293
294     my $nativeType = GetNativeTypeForConversions($dataNode, $interfaceName);
295     if ($dataNode->extendedAttributes->{"NamedConstructor"}) {
296         push(@headerContent, <<END);
297 class V8${nativeType}Constructor {
298 public:
299     static v8::Persistent<v8::FunctionTemplate> GetTemplate();
300     static WrapperTypeInfo info;
301 };
302
303 END
304     }
305
306     push(@headerContent, "class $className {\n");
307     push(@headerContent, "public:\n");
308
309     push(@headerContent, "    static const bool hasDependentLifetime = ");
310     if ($hasDependentLifetime) {
311         push(@headerContent, "true;\n");
312     } elsif (@{$dataNode->parents}) {
313         # Even if this type doesn't have the V8DependentLifetime attribute its parents may.
314         # Let the compiler statically determine this for us.
315         my $separator = "";
316         foreach (@{$dataNode->parents}) {
317             my $parent = $codeGenerator->StripModule($_);
318             next if $parent eq "EventTarget";
319             $headerIncludes{"V8${parent}.h"} = 1;
320             push(@headerContent, "${separator}V8${parent}::hasDependentLifetime");
321             $separator = " || ";
322         }
323         push(@headerContent, ";\n");
324     } else {
325         push(@headerContent, "false;\n");
326     }
327
328     my $domMapFunction = GetDomMapFunction($dataNode, $interfaceName);
329     my $forceNewObjectParameter = IsDOMNodeType($interfaceName) ? ", bool forceNewObject = false" : "";
330     my $forceNewObjectInput = IsDOMNodeType($interfaceName) ? ", bool forceNewObject" : "";
331     my $forceNewObjectCall = IsDOMNodeType($interfaceName) ? ", forceNewObject" : "";
332
333     push(@headerContent, <<END);
334     static bool HasInstance(v8::Handle<v8::Value>);
335     static v8::Persistent<v8::FunctionTemplate> GetRawTemplate();
336     static v8::Persistent<v8::FunctionTemplate> GetTemplate();
337     static ${nativeType}* toNative(v8::Handle<v8::Object> object)
338     {
339         return reinterpret_cast<${nativeType}*>(object->GetPointerFromInternalField(v8DOMWrapperObjectIndex));
340     }
341     inline static v8::Handle<v8::Object> wrap(${nativeType}*${forceNewObjectParameter});
342     static void derefObject(void*);
343     static WrapperTypeInfo info;
344 END
345     if ($dataNode->extendedAttributes->{"ActiveDOMObject"}) {
346         push(@headerContent, "    static ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object>);\n");
347     }
348
349     if ($implClassName eq "DOMWindow") {
350         push(@headerContent, <<END);
351     static v8::Persistent<v8::ObjectTemplate> GetShadowObjectTemplate();
352 END
353     }
354
355     if ($implClassName eq "HTMLDocument") {
356       push(@headerContent, <<END);
357   static v8::Local<v8::Object> WrapInShadowObject(v8::Local<v8::Object> wrapper, Node* impl);
358   static v8::Handle<v8::Value> GetNamedProperty(HTMLDocument* htmlDocument, const AtomicString& key);
359 END
360     }
361
362     my @enabledAtRuntime;
363     foreach my $function (@{$dataNode->functions}) {
364         my $name = $function->signature->name;
365         my $attrExt = $function->signature->extendedAttributes;
366
367         if (($attrExt->{"Custom"} || $attrExt->{"V8Custom"}) && !$attrExt->{"ImplementedBy"} && $function->{overloadIndex} == 1) {
368             my $conditionalString = GenerateConditionalString($function->signature);
369             push(@headerContent, "#if ${conditionalString}\n") if $conditionalString;
370             push(@headerContent, <<END);
371     static v8::Handle<v8::Value> ${name}Callback(const v8::Arguments&);
372 END
373             push(@headerContent, "#endif // ${conditionalString}\n") if $conditionalString;
374         }
375
376         if ($attrExt->{"V8EnabledAtRuntime"}) {
377             push(@enabledAtRuntime, $function);
378         }
379     }
380
381     if (IsConstructable($dataNode)) {
382         push(@headerContent, <<END);
383     static v8::Handle<v8::Value> constructorCallback(const v8::Arguments&);
384 END
385     }
386
387     foreach my $attribute (@{$dataNode->attributes}) {
388         my $name = $attribute->signature->name;
389         my $attrExt = $attribute->signature->extendedAttributes;
390         my $conditionalString = GenerateConditionalString($attribute->signature);
391         if (($attrExt->{"V8CustomGetter"} || $attrExt->{"CustomGetter"} ||
392              $attrExt->{"V8Custom"} || $attrExt->{"Custom"}) &&
393             !$attrExt->{"ImplementedBy"}) {
394             push(@headerContent, "#if ${conditionalString}\n") if $conditionalString;
395             push(@headerContent, <<END);
396     static v8::Handle<v8::Value> ${name}AccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo&);
397 END
398             push(@headerContent, "#endif // ${conditionalString}\n") if $conditionalString;
399         }
400         if (($attrExt->{"V8CustomSetter"} || $attrExt->{"CustomSetter"} ||
401              $attrExt->{"V8Custom"} || $attrExt->{"Custom"}) &&
402             !$attrExt->{"ImplementedBy"}) {
403             push(@headerContent, "#if ${conditionalString}\n") if $conditionalString;
404             push(@headerContent, <<END);
405     static void ${name}AccessorSetter(v8::Local<v8::String> name, v8::Local<v8::Value>, const v8::AccessorInfo&);
406 END
407             push(@headerContent, "#endif // ${conditionalString}\n") if $conditionalString;
408         }
409         if ($attrExt->{"V8EnabledAtRuntime"}) {
410             push(@enabledAtRuntime, $attribute);
411         }
412     }
413
414     GenerateHeaderNamedAndIndexedPropertyAccessors($dataNode);
415     GenerateHeaderCustomCall($dataNode);
416     GenerateHeaderCustomInternalFieldIndices($dataNode);
417
418     if ($dataNode->extendedAttributes->{"CheckSecurity"}) {
419         push(@headerContent, <<END);
420     static bool namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8::AccessType, v8::Local<v8::Value> data);
421     static bool indexedSecurityCheck(v8::Local<v8::Object> host, uint32_t index, v8::AccessType, v8::Local<v8::Value> data);
422 END
423     }
424
425     push(@headerContent, <<END);
426 private:
427     static v8::Handle<v8::Object> wrapSlow(${nativeType}*);
428 };
429
430 END
431
432     push(@headerContent, <<END);
433 v8::Handle<v8::Object> ${className}::wrap(${nativeType}* impl${forceNewObjectInput})
434 {
435 END
436     push(@headerContent, "    if (!forceNewObject) {\n") if IsDOMNodeType($interfaceName);
437     my $getCachedWrapper = IsNodeSubType($dataNode) ? "V8DOMWrapper::getCachedWrapper(impl)" : "${domMapFunction}.get(impl)";
438     push(@headerContent, <<END);
439         v8::Handle<v8::Object> wrapper = $getCachedWrapper;
440         if (!wrapper.IsEmpty())
441             return wrapper;
442 END
443     push(@headerContent, "    }\n") if IsDOMNodeType($interfaceName);
444     push(@headerContent, <<END);
445     return ${className}::wrapSlow(impl);
446 }
447 END
448
449     if ($interfaceName eq 'Element') {
450         # Do not generate toV8() for performance optimization.
451     } elsif (!($dataNode->extendedAttributes->{"CustomToJSObject"} or $dataNode->extendedAttributes->{"V8CustomToJSObject"})) {
452         push(@headerContent, <<END);
453
454 inline v8::Handle<v8::Value> toV8(${nativeType}* impl${forceNewObjectParameter})
455 {
456     if (!impl)
457         return v8::Null();
458     return ${className}::wrap(impl${forceNewObjectCall});
459 }
460 END
461     } elsif ($interfaceName ne 'Node') {
462         push(@headerContent, <<END);
463
464 v8::Handle<v8::Value> toV8(${nativeType}*${forceNewObjectParameter});
465 END
466     } else {
467         push(@headerContent, <<END);
468
469 v8::Handle<v8::Value> toV8Slow(Node*, bool);
470
471 inline v8::Handle<v8::Value> toV8(Node* impl, bool forceNewObject = false)
472 {
473     if (UNLIKELY(!impl))
474         return v8::Null();
475     if (UNLIKELY(forceNewObject))
476         return toV8Slow(impl, forceNewObject);
477     v8::Handle<v8::Value> wrapper = V8DOMWrapper::getCachedWrapper(impl);
478     if (!wrapper.IsEmpty())
479         return wrapper;
480     return toV8Slow(impl, false);
481 }
482 END
483     }
484
485     if (IsRefPtrType($implClassName)) {
486         push(@headerContent, <<END);
487 inline v8::Handle<v8::Value> toV8(PassRefPtr< ${nativeType} > impl${forceNewObjectParameter})
488 {
489     return toV8(impl.get()${forceNewObjectCall});
490 }
491 END
492     }
493
494     if (IsConstructorTemplate($dataNode, "Event")) {
495         push(@headerContent, "\nbool fill${implClassName}Init(${implClassName}Init&, const Dictionary&);\n");
496     }
497
498     push(@headerContent, "\n}\n\n");
499     push(@headerContent, "#endif // $className" . "_h\n");
500
501     my $conditionalString = GenerateConditionalString($dataNode);
502     push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditionalString;
503 }
504
505 sub GetInternalFields
506 {
507     my $dataNode = shift;
508     my $name = $dataNode->name;
509
510     my @customInternalFields = ();
511     # We can't ask whether a parent type has a given extendedAttribute,
512     # so special-case AbstractWorker and WorkerContext to include all sub-types.
513     # Event listeners on DOM nodes are explicitly supported in the GC controller.
514     # FIXME: SVGElementInstance should probably have the EventTarget extended attribute, but doesn't.
515     if (!IsNodeSubType($dataNode)
516         && ($dataNode->extendedAttributes->{"EventTarget"}
517             || $dataNode->extendedAttributes->{"IsWorkerContext"}
518             || IsSubType($dataNode, "AbstractWorker")
519             || $name eq "SVGElementInstance")) {
520         push(@customInternalFields, "eventListenerCacheIndex");
521     }
522
523     if ($name eq "DOMWindow") {
524         push(@customInternalFields, "enteredIsolatedWorldIndex");
525     }
526     return @customInternalFields;
527 }
528
529 sub GetHeaderClassInclude
530 {
531     my $className = shift;
532     if ($className =~ /SVGPathSeg/) {
533         $className =~ s/Abs|Rel//;
534     }
535     return "wtf/${className}.h" if IsTypedArrayType($className);
536     return "" if ($codeGenerator->AvoidInclusionOfType($className));
537     return "${className}.h";
538 }
539
540 sub GenerateHeaderCustomInternalFieldIndices
541 {
542     my $dataNode = shift;
543     my @customInternalFields = GetInternalFields($dataNode);
544     my $customFieldCounter = 0;
545     foreach my $customInternalField (@customInternalFields) {
546         push(@headerContent, <<END);
547     static const int ${customInternalField} = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
548 END
549         $customFieldCounter++;
550     }
551     push(@headerContent, <<END);
552     static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
553 END
554 }
555
556 my %indexerSpecialCases = (
557     "Storage" => 1,
558     "HTMLAppletElement" => 1,
559     "HTMLEmbedElement" => 1,
560     "HTMLObjectElement" => 1
561 );
562
563 sub GenerateHeaderNamedAndIndexedPropertyAccessors
564 {
565     my $dataNode = shift;
566     my $interfaceName = $dataNode->name;
567     my $hasCustomIndexedGetter = $dataNode->extendedAttributes->{"IndexedGetter"} || $dataNode->extendedAttributes->{"CustomGetOwnPropertySlot"};
568     my $hasCustomIndexedSetter = $dataNode->extendedAttributes->{"CustomIndexedSetter"} && !$dataNode->extendedAttributes->{"NumericIndexedGetter"};
569     my $hasCustomNamedGetter = $dataNode->extendedAttributes->{"NamedGetter"} || $dataNode->extendedAttributes->{"CustomNamedGetter"} || $dataNode->extendedAttributes->{"CustomGetOwnPropertySlot"};
570     my $hasCustomNamedSetter = $dataNode->extendedAttributes->{"CustomNamedSetter"};
571     my $hasCustomDeleters = $dataNode->extendedAttributes->{"CustomDeleteProperty"};
572     my $hasCustomEnumerator = $dataNode->extendedAttributes->{"CustomEnumerateProperty"};
573     if ($interfaceName eq "HTMLOptionsCollection") {
574         $interfaceName = "HTMLCollection";
575         $hasCustomIndexedGetter = 1;
576         $hasCustomNamedGetter = 1;
577     }
578     if ($interfaceName eq "DOMWindow") {
579         $hasCustomDeleters = 0;
580         $hasCustomEnumerator = 0;
581     }
582     if ($interfaceName eq "HTMLAppletElement" || $interfaceName eq "HTMLEmbedElement" || $interfaceName eq "HTMLObjectElement") {
583         $hasCustomNamedGetter = 1;
584     }
585     if ($interfaceName eq "HTMLDocument") {
586         $hasCustomNamedGetter = 0;
587         $hasCustomIndexedGetter = 0;
588     }
589     my $isIndexerSpecialCase = exists $indexerSpecialCases{$interfaceName};
590
591     if ($hasCustomIndexedGetter || $isIndexerSpecialCase) {
592         push(@headerContent, <<END);
593     static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t, const v8::AccessorInfo&);
594 END
595     }
596
597     if ($isIndexerSpecialCase || $hasCustomIndexedSetter) {
598         push(@headerContent, <<END);
599     static v8::Handle<v8::Value> indexedPropertySetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
600 END
601     }
602     if ($hasCustomDeleters) {
603         push(@headerContent, <<END);
604     static v8::Handle<v8::Boolean> indexedPropertyDeleter(uint32_t, const v8::AccessorInfo&);
605 END
606     }
607     if ($hasCustomNamedGetter) {
608         push(@headerContent, <<END);
609     static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String>, const v8::AccessorInfo&);
610 END
611     }
612     if ($hasCustomNamedSetter) {
613         push(@headerContent, <<END);
614     static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String>, v8::Local<v8::Value>, const v8::AccessorInfo&);
615 END
616     }
617     if ($hasCustomDeleters) {
618         push(@headerContent, <<END);
619     static v8::Handle<v8::Boolean> namedPropertyDeleter(v8::Local<v8::String>, const v8::AccessorInfo&);
620 END
621     }
622     if ($hasCustomEnumerator) {
623         push(@headerContent, <<END);
624     static v8::Handle<v8::Array> namedPropertyEnumerator(const v8::AccessorInfo&);
625     static v8::Handle<v8::Integer> namedPropertyQuery(v8::Local<v8::String>, const v8::AccessorInfo&);
626 END
627     }
628 }
629
630 sub GenerateHeaderCustomCall
631 {
632     my $dataNode = shift;
633
634     if ($dataNode->extendedAttributes->{"CustomCall"}) {
635         push(@headerContent, "    static v8::Handle<v8::Value> callAsFunctionCallback(const v8::Arguments&);\n");
636     }
637     if ($dataNode->name eq "Event") {
638         push(@headerContent, "    static v8::Handle<v8::Value> dataTransferAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo&);\n");
639         push(@headerContent, "    static void valueAccessorSetter(v8::Local<v8::String> name, v8::Local<v8::Value>, const v8::AccessorInfo&);\n");
640     }
641     if ($dataNode->name eq "Location") {
642         push(@headerContent, "    static v8::Handle<v8::Value> assignAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo&);\n");
643         push(@headerContent, "    static v8::Handle<v8::Value> reloadAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo&);\n");
644         push(@headerContent, "    static v8::Handle<v8::Value> replaceAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo&);\n");
645     }
646 }
647
648 sub GenerateSetDOMException
649 {
650     my $indent = shift;
651     my $result = "";
652
653     $result .= $indent . "if (UNLIKELY(ec)) {\n";
654     $result .= $indent . "    V8Proxy::setDOMException(ec);\n";
655     $result .= $indent . "    return v8::Handle<v8::Value>();\n";
656     $result .= $indent . "}\n";
657
658     return $result;
659 }
660
661 sub IsSubType
662 {
663     my $dataNode = shift;
664     my $parentType = shift;
665     return 1 if ($dataNode->name eq $parentType);
666     foreach (@allParents) {
667         my $parent = $codeGenerator->StripModule($_);
668         return 1 if $parent eq $parentType;
669     }
670     return 0;
671 }
672
673 sub IsNodeSubType
674 {
675     my $dataNode = shift;
676     return IsSubType($dataNode, "Node");
677 }
678
679 sub IsVisibleAcrossOrigins
680 {
681     my $dataNode = shift;
682     return $dataNode->extendedAttributes->{"CheckSecurity"} && !($dataNode->name eq "DOMWindow");
683 }
684
685 sub IsConstructable
686 {
687     my $dataNode = shift;
688
689     return $dataNode->extendedAttributes->{"CustomConstructor"} || $dataNode->extendedAttributes->{"V8CustomConstructor"} || $dataNode->extendedAttributes->{"Constructor"} || $dataNode->extendedAttributes->{"ConstructorTemplate"};
690 }
691
692 sub IsConstructorTemplate
693 {
694     my $dataNode = shift;
695     my $template = shift;
696
697     return $dataNode->extendedAttributes->{"ConstructorTemplate"} && $dataNode->extendedAttributes->{"ConstructorTemplate"} eq $template;
698 }
699
700 sub GenerateDomainSafeFunctionGetter
701 {
702     my $function = shift;
703     my $implClassName = shift;
704
705     my $className = "V8" . $implClassName;
706     my $funcName = $function->signature->name;
707
708     my $signature = "v8::Signature::New(" . $className . "::GetRawTemplate())";
709     if ($function->signature->extendedAttributes->{"V8DoNotCheckSignature"}) {
710         $signature = "v8::Local<v8::Signature>()";
711     }
712
713     my $newTemplateString = GenerateNewFunctionTemplate($function, $implClassName, $signature);
714
715     push(@implContentDecls, <<END);
716 static v8::Handle<v8::Value> ${funcName}AttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
717 {
718     INC_STATS(\"DOM.$implClassName.$funcName._get\");
719     static v8::Persistent<v8::FunctionTemplate> privateTemplate = v8::Persistent<v8::FunctionTemplate>::New($newTemplateString);
720     v8::Handle<v8::Object> holder = V8DOMWrapper::lookupDOMWrapper(${className}::GetTemplate(), info.This());
721     if (holder.IsEmpty()) {
722         // can only reach here by 'object.__proto__.func', and it should passed
723         // domain security check already
724         return privateTemplate->GetFunction();
725     }
726     ${implClassName}* imp = ${className}::toNative(holder);
727     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), false)) {
728         static v8::Persistent<v8::FunctionTemplate> sharedTemplate = v8::Persistent<v8::FunctionTemplate>::New($newTemplateString);
729         return sharedTemplate->GetFunction();
730     }
731     return privateTemplate->GetFunction();
732 }
733
734 END
735 }
736
737 sub GenerateConstructorGetter
738 {
739     my $dataNode = shift;
740     my $implClassName = shift;
741
742     push(@implContentDecls, <<END);
743 static v8::Handle<v8::Value> ${implClassName}ConstructorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
744 {
745     INC_STATS(\"DOM.$implClassName.constructors._get\");
746     v8::Handle<v8::Value> data = info.Data();
747     ASSERT(data->IsExternal() || data->IsNumber());
748     WrapperTypeInfo* type = WrapperTypeInfo::unwrap(data);
749 END
750
751     if ($implClassName eq "DOMWindow") {
752         push(@implContentDecls, <<END);
753     // Get the proxy corresponding to the DOMWindow if possible to
754     // make sure that the constructor function is constructed in the
755     // context of the DOMWindow and not in the context of the caller.
756     return V8DOMWrapper::getConstructor(type, V8DOMWindow::toNative(info.Holder()));
757 END
758     } elsif ($dataNode->extendedAttributes->{"IsWorkerContext"}) {
759         push(@implContentDecls, <<END);
760     return V8DOMWrapper::getConstructor(type, V8WorkerContext::toNative(info.Holder()));
761 END
762     } else {
763         push(@implContentDecls, "    return v8::Handle<v8::Value>();");
764     }
765
766     push(@implContentDecls, <<END);
767 }
768
769 END
770 }
771
772 sub GenerateNormalAttrGetter
773 {
774     my $attribute = shift;
775     my $dataNode = shift;
776     my $implClassName = shift;
777     my $interfaceName = shift;
778
779     my $attrExt = $attribute->signature->extendedAttributes;
780     my $attrName = $attribute->signature->name;
781     my $attrType = GetTypeFromSignature($attribute->signature);
782     my $nativeType = GetNativeTypeFromSignature($attribute->signature, -1);
783
784     my $getterStringUsesImp = $implClassName ne "SVGNumber";
785     my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($implClassName);
786
787     # Getter
788     my $conditionalString = GenerateConditionalString($attribute->signature);
789     push(@implContentDecls, "#if ${conditionalString}\n\n") if $conditionalString;
790
791     push(@implContentDecls, <<END);
792 static v8::Handle<v8::Value> ${attrName}AttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
793 {
794     INC_STATS(\"DOM.$implClassName.$attrName._get\");
795 END
796
797     if ($svgNativeType) {
798         my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implClassName);
799         if ($svgWrappedNativeType =~ /List/) {
800             push(@implContentDecls, <<END);
801     $svgNativeType* imp = V8${implClassName}::toNative(info.Holder());
802 END
803         } else {
804             push(@implContentDecls, <<END);
805     $svgNativeType* wrapper = V8${implClassName}::toNative(info.Holder());
806     $svgWrappedNativeType& impInstance = wrapper->propertyReference();
807 END
808             if ($getterStringUsesImp) {
809                 push(@implContentDecls, <<END);
810     $svgWrappedNativeType* imp = &impInstance;
811 END
812             }
813         }
814     } elsif ($attrExt->{"V8OnProto"} || $attrExt->{"V8Unforgeable"}) {
815         if ($interfaceName eq "DOMWindow") {
816             push(@implContentDecls, <<END);
817     v8::Handle<v8::Object> holder = info.Holder();
818 END
819         } else {
820             # perform lookup first
821             push(@implContentDecls, <<END);
822     v8::Handle<v8::Object> holder = V8DOMWrapper::lookupDOMWrapper(V8${interfaceName}::GetTemplate(), info.This());
823     if (holder.IsEmpty())
824         return v8::Handle<v8::Value>();
825 END
826         }
827         push(@implContentDecls, <<END);
828     ${implClassName}* imp = V8${implClassName}::toNative(holder);
829 END
830     } else {
831         my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
832         my $url = $attribute->signature->extendedAttributes->{"URL"};
833         if ($getterStringUsesImp && $reflect && !$url && IsNodeSubType($dataNode) && $codeGenerator->IsStringType($attrType)) {
834             # Generate super-compact call for regular attribute getter:
835             my $contentAttributeName = $reflect eq "VALUE_IS_MISSING" ? lc $attrName : $reflect;
836             my $namespace = $codeGenerator->NamespaceForAttributeName($interfaceName, $contentAttributeName);
837             AddToImplIncludes("${namespace}.h");
838             push(@implContentDecls, "    return getElementStringAttr(info, ${namespace}::${contentAttributeName}Attr);\n");
839             push(@implContentDecls, "}\n\n");
840             push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
841             return;
842             # Skip the rest of the function!
843         }
844         if ($attribute->signature->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
845             push(@implContentDecls, <<END);
846     v8::Handle<v8::String> propertyName = v8::String::NewSymbol("${attrName}");
847     v8::Handle<v8::Value> value = info.Holder()->GetHiddenValue(propertyName);
848     if (!value.IsEmpty())
849         return value;
850 END
851         }
852         push(@implContentDecls, <<END);
853     ${implClassName}* imp = V8${implClassName}::toNative(info.Holder());
854 END
855     }
856
857     # Generate security checks if necessary
858     if ($attribute->signature->extendedAttributes->{"CheckSecurityForNode"}) {
859         push(@implContentDecls, "    if (!V8BindingSecurity::shouldAllowAccessToNode(V8BindingState::Only(), imp->" . $attribute->signature->name . "()))\n        return v8::Handle<v8::Value>(v8::Null());\n\n");
860     }
861
862     my $useExceptions = 1 if @{$attribute->getterExceptions};
863     if ($useExceptions) {
864         AddToImplIncludes("ExceptionCode.h");
865         push(@implContentDecls, "    ExceptionCode ec = 0;\n");
866     }
867
868     my $returnType = GetTypeFromSignature($attribute->signature);
869     my $getterString;
870
871     if ($getterStringUsesImp) {
872         my ($functionName, @arguments) = $codeGenerator->GetterExpression(\%implIncludes, $interfaceName, $attribute);
873
874         push(@arguments, GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, \@implContentDecls, "    ", 0, 0));
875
876         push(@arguments, "ec") if $useExceptions;
877         if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
878             my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
879             AddToImplIncludes("${implementedBy}.h");
880             unshift(@arguments, "imp");
881             $functionName = "${implementedBy}::${functionName}";
882         } else {
883             $functionName = "imp->${functionName}";
884         }
885         $getterString = "${functionName}(" . join(", ", @arguments) . ")";
886     } else {
887         $getterString = "impInstance";
888     }
889
890     my $result;
891     my $wrapper;
892
893     if ($attribute->signature->type eq "EventListener" && $dataNode->name eq "DOMWindow") {
894         push(@implContentDecls, "    if (!imp->document())\n");
895         push(@implContentDecls, "        return v8::Handle<v8::Value>();\n");
896     }
897
898     if ($useExceptions) {
899         if ($nativeType =~ /^V8Parameter/) {
900             push(@implContentDecls, "    " . ConvertToV8Parameter($attribute->signature, $nativeType, "v", $getterString) . ";\n");
901         } else {
902             push(@implContentDecls, "    $nativeType v = $getterString;\n");
903         }
904         push(@implContentDecls, GenerateSetDOMException("    "));
905
906         if ($codeGenerator->ExtendedAttributeContains($attribute->signature->extendedAttributes->{"CallWith"}, "ScriptState")) {
907             push(@implContentDecls, "    if (state.hadException())\n");
908             push(@implContentDecls, "        return throwError(state.exception());\n");
909         }
910
911         $result = "v";
912         $result .= ".release()" if (IsRefPtrType($returnType));
913     } else {
914         # Can inline the function call into the return statement to avoid overhead of using a Ref<> temporary
915         $result = $getterString;
916         # Fix amigious conversion problem, by casting to the base type first ($getterString returns a type that inherits from SVGAnimatedEnumeration, not the base class directly).
917         $result = "static_pointer_cast<SVGAnimatedEnumeration>($result)" if $returnType eq "SVGAnimatedEnumeration";
918     }
919  
920     # Special case for readonly or Replaceable attributes (with a few exceptions). This attempts to ensure that JS wrappers don't get
921     # garbage-collected prematurely when their lifetime is strongly tied to their owner. We accomplish this by inserting a reference to
922     # the newly created wrapper into an internal field of the holder object.
923     if (!IsNodeSubType($dataNode) && $attrName ne "self" && (IsWrapperType($returnType) && ($attribute->type =~ /^readonly/ || $attribute->signature->extendedAttributes->{"Replaceable"})
924         && $returnType ne "EventTarget" && $returnType ne "SerializedScriptValue" && $returnType ne "DOMWindow" 
925         && $returnType !~ /SVG/ && $returnType !~ /HTML/ && !IsDOMNodeType($returnType))) {
926
927         my $arrayType = $codeGenerator->GetArrayType($returnType);
928         if ($arrayType) {
929             AddToImplIncludes("V8$arrayType.h");
930             AddToImplIncludes("$arrayType.h");
931             push(@implContentDecls, "    const Vector<RefPtr<$arrayType> > vector = ${getterString};\n");
932             push(@implContentDecls, "    return v8Array(vector);\n");
933             push(@implContentDecls, "}\n\n");
934             return;
935         }
936
937         AddIncludesForType($returnType);
938         # Check for a wrapper in the wrapper cache. If there is one, we know that a hidden reference has already
939         # been created. If we don't find a wrapper, we create both a wrapper and a hidden reference.
940         push(@implContentDecls, "    RefPtr<$returnType> result = ${getterString};\n");
941         my $domMapFunction = GetDomMapFunction($dataNode, $interfaceName);
942         push(@implContentDecls, "    v8::Handle<v8::Value> wrapper = result.get() ? ${domMapFunction}.get(result.get()) : v8::Handle<v8::Object>();\n");
943         push(@implContentDecls, "    if (wrapper.IsEmpty()) {\n");
944         push(@implContentDecls, "        wrapper = toV8(result.get());\n");
945         push(@implContentDecls, "        if (!wrapper.IsEmpty())\n");
946         if ($dataNode->name eq "DOMWindow") {
947             push(@implContentDecls, "            V8DOMWrapper::setNamedHiddenWindowReference(imp->frame(), \"${attrName}\", wrapper);\n");
948         } else {
949             push(@implContentDecls, "            V8DOMWrapper::setNamedHiddenReference(info.Holder(), \"${attrName}\", wrapper);\n");
950         }
951         push(@implContentDecls, "    }\n");
952         push(@implContentDecls, "    return wrapper;\n");
953         push(@implContentDecls, "}\n\n");
954         push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
955         return;
956     }
957
958     if ($codeGenerator->IsSVGAnimatedType($implClassName) and $codeGenerator->IsSVGTypeNeedingTearOff($attrType)) {
959         AddToImplIncludes("V8$attrType.h");
960         my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($attrType);
961         # Convert from abstract SVGProperty to real type, so the right toJS() method can be invoked.
962         push(@implContentDecls, "    return toV8(static_cast<$svgNativeType*>($result));\n");
963     } elsif ($codeGenerator->IsSVGTypeNeedingTearOff($attrType) and not $implClassName =~ /List$/) {
964         AddToImplIncludes("V8$attrType.h");
965         AddToImplIncludes("SVGPropertyTearOff.h");
966         my $tearOffType = $codeGenerator->GetSVGTypeNeedingTearOff($attrType);
967         if ($codeGenerator->IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->signature->extendedAttributes->{"Immutable"}) {
968             my $getter = $result;
969             $getter =~ s/imp->//;
970             $getter =~ s/\(\)//;
971
972             my $updateMethod = "&${implClassName}::update" . $codeGenerator->WK_ucfirst($getter);
973
974             my $selfIsTearOffType = $codeGenerator->IsSVGTypeNeedingTearOff($implClassName);
975             if ($selfIsTearOffType) {
976                 AddToImplIncludes("SVGStaticPropertyWithParentTearOff.h");
977                 $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyWithParentTearOff<$implClassName, /;
978
979                 if ($result =~ /matrix/ and $implClassName eq "SVGTransform") {
980                     # SVGTransform offers a matrix() method for internal usage that returns an AffineTransform
981                     # and a svgMatrix() method returning a SVGMatrix, used for the bindings.
982                     $result =~ s/matrix/svgMatrix/;
983                 }
984
985                 push(@implContentDecls, "    return toV8(WTF::getPtr(${tearOffType}::create(wrapper, $result, $updateMethod)));\n");
986             } else {
987                 AddToImplIncludes("SVGStaticPropertyTearOff.h");
988                 $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyTearOff<$implClassName, /;
989
990                 push(@implContentDecls, "    return toV8(WTF::getPtr(${tearOffType}::create(imp, $result, $updateMethod)));\n");
991             }
992         } elsif ($tearOffType =~ /SVGStaticListPropertyTearOff/) {
993             push(@implContentDecls, "    return toV8(WTF::getPtr(${tearOffType}::create(imp, $result)));\n");
994         } elsif ($tearOffType =~ /SVG(Point|PathSeg)List/) {
995             push(@implContentDecls, "    return toV8(WTF::getPtr($result));\n");
996         } else {
997             push(@implContentDecls, "    return toV8(WTF::getPtr(${tearOffType}::create($result)));\n");
998         }
999     } else {
1000         if ($attribute->signature->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
1001             my $getterFunc = $codeGenerator->WK_lcfirst($attribute->signature->name);
1002             push(@implContentDecls, <<END);
1003     SerializedScriptValue* serialized = imp->${getterFunc}();
1004     value = serialized ? serialized->deserialize() : v8::Handle<v8::Value>(v8::Null());
1005     info.Holder()->SetHiddenValue(propertyName, value);
1006     return value;
1007 END
1008         } else {
1009             push(@implContentDecls, "    " . ReturnNativeToJSValue($attribute->signature, $result, "    ").";\n");
1010         }
1011     }
1012
1013     push(@implContentDecls, "}\n\n");  # end of getter
1014     push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
1015 }
1016
1017 sub GenerateNormalAttrSetter
1018 {
1019     my $attribute = shift;
1020     my $dataNode = shift;
1021     my $implClassName = shift;
1022     my $interfaceName = shift;
1023
1024     AddToImplIncludes("V8BindingMacros.h");
1025
1026     my $attrName = $attribute->signature->name;
1027     my $attrExt = $attribute->signature->extendedAttributes;
1028
1029     my $conditionalString = GenerateConditionalString($attribute->signature);
1030     push(@implContentDecls, "#if ${conditionalString}\n\n") if $conditionalString;
1031
1032     push(@implContentDecls, "static void ${attrName}AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)\n{\n");
1033     push(@implContentDecls, "    INC_STATS(\"DOM.$implClassName.$attrName._set\");\n");
1034
1035     # If the "StrictTypeChecking" extended attribute is present, and the attribute's type is an
1036     # interface type, then if the incoming value does not implement that interface, a TypeError is
1037     # thrown rather than silently passing NULL to the C++ code.
1038     # Per the Web IDL and ECMAScript specifications, incoming values can always be converted to both
1039     # strings and numbers, so do not throw TypeError if the attribute is of these types.
1040     if ($attribute->signature->extendedAttributes->{"StrictTypeChecking"}) {
1041         my $argType = GetTypeFromSignature($attribute->signature);
1042         if (IsWrapperType($argType)) {
1043             push(@implContentDecls, "    if (!isUndefinedOrNull(value) && !V8${argType}::HasInstance(value)) {\n");
1044             push(@implContentDecls, "        V8Proxy::throwTypeError();\n");
1045             push(@implContentDecls, "        return;\n");
1046             push(@implContentDecls, "    }\n");
1047         }
1048     }
1049
1050     my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($implClassName);
1051     if ($svgNativeType) {
1052         my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implClassName);
1053         if ($svgWrappedNativeType =~ /List$/) {
1054             push(@implContentDecls, <<END);
1055     $svgNativeType* imp = V8${implClassName}::toNative(info.Holder());
1056 END
1057         } else {
1058             AddToImplIncludes("ExceptionCode.h");
1059             push(@implContentDecls, "    $svgNativeType* wrapper = V8${implClassName}::toNative(info.Holder());\n");
1060             push(@implContentDecls, "    if (wrapper->role() == AnimValRole) {\n");
1061             push(@implContentDecls, "        V8Proxy::setDOMException(NO_MODIFICATION_ALLOWED_ERR);\n");
1062             push(@implContentDecls, "        return;\n");
1063             push(@implContentDecls, "    }\n");
1064             push(@implContentDecls, "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n");
1065             push(@implContentDecls, "    $svgWrappedNativeType* imp = &impInstance;\n");
1066         }
1067     } elsif ($attrExt->{"V8OnProto"}) {
1068       if ($interfaceName eq "DOMWindow") {
1069         push(@implContentDecls, <<END);
1070     v8::Handle<v8::Object> holder = info.Holder();
1071 END
1072       } else {
1073         # perform lookup first
1074         push(@implContentDecls, <<END);
1075     v8::Handle<v8::Object> holder = V8DOMWrapper::lookupDOMWrapper(V8${interfaceName}::GetTemplate(), info.This());
1076     if (holder.IsEmpty())
1077         return;
1078 END
1079       }
1080     push(@implContentDecls, <<END);
1081     ${implClassName}* imp = V8${implClassName}::toNative(holder);
1082 END
1083     } else {
1084         my $attrType = GetTypeFromSignature($attribute->signature);
1085         my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
1086         if ($reflect && IsNodeSubType($dataNode) && $codeGenerator->IsStringType($attrType)) {
1087             # Generate super-compact call for regular attribute setter:
1088             my $contentAttributeName = $reflect eq "VALUE_IS_MISSING" ? lc $attrName : $reflect;
1089             my $namespace = $codeGenerator->NamespaceForAttributeName($interfaceName, $contentAttributeName);
1090             AddToImplIncludes("${namespace}.h");
1091             push(@implContentDecls, "    setElementStringAttr(info, ${namespace}::${contentAttributeName}Attr, value);\n");
1092             push(@implContentDecls, "}\n\n");
1093             push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
1094             return;
1095             # Skip the rest of the function!
1096         }
1097
1098         push(@implContentDecls, <<END);
1099     ${implClassName}* imp = V8${implClassName}::toNative(info.Holder());
1100 END
1101     }
1102
1103     my $nativeType = GetNativeTypeFromSignature($attribute->signature, 0);
1104     if ($attribute->signature->type eq "EventListener") {
1105         if ($dataNode->name eq "DOMWindow") {
1106             push(@implContentDecls, "    if (!imp->document())\n");
1107             push(@implContentDecls, "        return;\n");
1108         }
1109     } else {
1110         my $value = JSValueToNative($attribute->signature, "value");
1111         my $arrayType = $codeGenerator->GetArrayType($nativeType);
1112
1113         if ($nativeType =~ /^V8Parameter/) {
1114             push(@implContentDecls, "    " . ConvertToV8Parameter($attribute->signature, $nativeType, "v", $value, "VOID") . "\n");
1115         } elsif ($arrayType) {
1116             push(@implContentDecls, "    Vector<$arrayType> v = $value;\n");
1117         } else {
1118             push(@implContentDecls, "    $nativeType v = $value;\n");
1119         }
1120     }
1121
1122     my $result = "v";
1123     my $returnType = GetTypeFromSignature($attribute->signature);
1124     if (IsRefPtrType($returnType) && !$codeGenerator->GetArrayType($returnType)) {
1125         $result = "WTF::getPtr(" . $result . ")";
1126     }
1127
1128     my $useExceptions = 1 if @{$attribute->setterExceptions};
1129
1130     if ($useExceptions) {
1131         AddToImplIncludes("ExceptionCode.h");
1132         push(@implContentDecls, "    ExceptionCode ec = 0;\n");
1133     }
1134
1135     if ($implClassName eq "SVGNumber") {
1136         push(@implContentDecls, "    *imp = $result;\n");
1137     } else {
1138         if ($attribute->signature->type eq "EventListener") {
1139             my $implSetterFunctionName = $codeGenerator->WK_ucfirst($attrName);
1140             AddToImplIncludes("V8AbstractEventListener.h");
1141             if (!IsNodeSubType($dataNode)) {
1142                 push(@implContentDecls, "    transferHiddenDependency(info.Holder(), imp->$attrName(), value, V8${interfaceName}::eventListenerCacheIndex);\n");
1143             }
1144             if ($interfaceName eq "WorkerContext" and $attribute->signature->name eq "onerror") {
1145                 AddToImplIncludes("V8EventListenerList.h");
1146                 AddToImplIncludes("V8WorkerContextErrorHandler.h");
1147                 push(@implContentDecls, "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8WorkerContextErrorHandler>(value, true)");
1148             } elsif ($interfaceName eq "DOMWindow" and $attribute->signature->name eq "onerror") {
1149                 AddToImplIncludes("V8EventListenerList.h");
1150                 AddToImplIncludes("V8WindowErrorHandler.h");
1151                 push(@implContentDecls, "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8WindowErrorHandler>(value, true)");
1152             } else {
1153                 push(@implContentDecls, "    imp->set$implSetterFunctionName(V8DOMWrapper::getEventListener(value, true, ListenerFindOrCreate)");
1154             }
1155             push(@implContentDecls, ", ec") if $useExceptions;
1156             push(@implContentDecls, ");\n");
1157         } else {
1158             my ($functionName, @arguments) = $codeGenerator->SetterExpression(\%implIncludes, $interfaceName, $attribute);
1159
1160             push(@arguments, GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, \@implContentDecls, "    ", 1, 0));
1161
1162             push(@arguments, $result);
1163             push(@arguments, "ec") if $useExceptions;
1164             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
1165                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
1166                 AddToImplIncludes("${implementedBy}.h");
1167                 unshift(@arguments, "imp");
1168                 $functionName = "${implementedBy}::${functionName}";
1169             } else {
1170                 $functionName = "imp->${functionName}";
1171             }
1172             push(@implContentDecls, "    ${functionName}(" . join(", ", @arguments) . ");\n");
1173         }
1174     }
1175
1176     if ($useExceptions) {
1177         push(@implContentDecls, "    if (UNLIKELY(ec))\n");
1178         push(@implContentDecls, "        V8Proxy::setDOMException(ec);\n");
1179     }
1180
1181     if ($codeGenerator->ExtendedAttributeContains($attribute->signature->extendedAttributes->{"CallWith"}, "ScriptState")) {
1182         push(@implContentDecls, "    if (state.hadException())\n");
1183         push(@implContentDecls, "        throwError(state.exception());\n");
1184     }
1185
1186     if ($svgNativeType) {
1187         if ($useExceptions) {
1188             push(@implContentDecls, "    if (!ec)\n");
1189             push(@implContentDecls, "        wrapper->commitChange();\n");
1190         } else {
1191             push(@implContentDecls, "    wrapper->commitChange();\n");
1192         }
1193     }
1194
1195     if ($attribute->signature->type eq "SerializedScriptValue" && $attribute->signature->extendedAttributes->{"CachedAttribute"}) {
1196         push(@implContentDecls, <<END);
1197     info.Holder()->DeleteHiddenValue(v8::String::NewSymbol("${attrName}")); // Invalidate the cached value.
1198 END
1199     }
1200
1201     push(@implContentDecls, "    return;\n");
1202     push(@implContentDecls, "}\n\n");  # end of setter
1203     push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
1204 }
1205
1206 sub GetFunctionTemplateCallbackName
1207 {
1208     my $function = shift;
1209     my $interfaceName = shift;
1210
1211     my $name = $function->signature->name;
1212
1213     if ($function->signature->extendedAttributes->{"Custom"} ||
1214         $function->signature->extendedAttributes->{"V8Custom"}) {
1215         if ($function->signature->extendedAttributes->{"Custom"} &&
1216             $function->signature->extendedAttributes->{"V8Custom"}) {
1217             die "Custom and V8Custom should be mutually exclusive!"
1218         }
1219         return "V8${interfaceName}::${name}Callback";
1220     } else {
1221         return "${interfaceName}Internal::${name}Callback";
1222     }
1223 }
1224
1225 sub GenerateNewFunctionTemplate
1226 {
1227     my $function = shift;
1228     my $interfaceName = shift;
1229     my $signature = shift;
1230
1231     my $callback = GetFunctionTemplateCallbackName($function, $interfaceName);
1232     return "v8::FunctionTemplate::New($callback, v8::Handle<v8::Value>(), $signature)";
1233 }
1234
1235 sub GenerateEventListenerCallback
1236 {
1237     my $implClassName = shift;
1238     my $requiresHiddenDependency = shift;
1239     my $functionName = shift;
1240     my $lookupType = ($functionName eq "add") ? "OrCreate" : "Only";
1241     my $passRefPtrHandling = ($functionName eq "add") ? "" : ".get()";
1242     my $hiddenDependencyAction = ($functionName eq "add") ? "create" : "remove";
1243  
1244     push(@implContentDecls, <<END);
1245 static v8::Handle<v8::Value> ${functionName}EventListenerCallback(const v8::Arguments& args)
1246 {
1247     INC_STATS("DOM.${implClassName}.${functionName}EventListener()");
1248     RefPtr<EventListener> listener = V8DOMWrapper::getEventListener(args[1], false, ListenerFind${lookupType});
1249     if (listener) {
1250         V8${implClassName}::toNative(args.Holder())->${functionName}EventListener(v8ValueToAtomicWebCoreString(args[0]), listener${passRefPtrHandling}, args[2]->BooleanValue());
1251 END
1252     if ($requiresHiddenDependency) {
1253         push(@implContentDecls, <<END);
1254         ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], V8${implClassName}::eventListenerCacheIndex);
1255 END
1256     }
1257     push(@implContentDecls, <<END);
1258     }
1259     return v8::Undefined();
1260 }
1261
1262 END
1263 }
1264
1265 sub GenerateParametersCheckExpression
1266 {
1267     my $numParameters = shift;
1268     my $function = shift;
1269
1270     my @andExpression = ();
1271     push(@andExpression, "args.Length() == $numParameters");
1272     my $parameterIndex = 0;
1273     foreach my $parameter (@{$function->parameters}) {
1274         last if $parameterIndex >= $numParameters;
1275         my $value = "args[$parameterIndex]";
1276         my $type = GetTypeFromSignature($parameter);
1277
1278         # Only DOMString or wrapper types are checked.
1279         # For DOMString, Null, Undefined and any Object are accepted too, as
1280         # these are acceptable values for a DOMString argument (any Object can
1281         # be converted to a string via .toString).
1282         if ($codeGenerator->IsStringType($type)) {
1283             push(@andExpression, "(${value}->IsNull() || ${value}->IsUndefined() || ${value}->IsString() || ${value}->IsObject())");
1284         } elsif ($parameter->extendedAttributes->{"Callback"}) {
1285             # For Callbacks only checks if the value is null or object.
1286             push(@andExpression, "(${value}->IsNull() || ${value}->IsObject())");
1287         } elsif (IsArrayType($type)) {
1288             # FIXME: Add proper support for T[], T[]?, sequence<T>.
1289             push(@andExpression, "(${value}->IsNull() || ${value}->IsArray())");
1290         } elsif (IsWrapperType($type)) {
1291             push(@andExpression, "(${value}->IsNull() || V8${type}::HasInstance($value))");
1292         }
1293
1294         $parameterIndex++;
1295     }
1296     my $res = join(" && ", @andExpression);
1297     $res = "($res)" if @andExpression > 1;
1298     return $res;
1299 }
1300
1301 sub GenerateFunctionParametersCheck
1302 {
1303     my $function = shift;
1304
1305     my @orExpression = ();
1306     my $numParameters = 0;
1307     foreach my $parameter (@{$function->parameters}) {
1308         if ($parameter->extendedAttributes->{"Optional"}) {
1309             push(@orExpression, GenerateParametersCheckExpression($numParameters, $function));
1310         }
1311         $numParameters++;
1312     }
1313     push(@orExpression, GenerateParametersCheckExpression($numParameters, $function));
1314     return join(" || ", @orExpression);
1315 }
1316
1317 sub GenerateOverloadedFunctionCallback
1318 {
1319     my $function = shift;
1320     my $dataNode = shift;
1321     my $implClassName = shift;
1322
1323     # Generate code for choosing the correct overload to call. Overloads are
1324     # chosen based on the total number of arguments passed and the type of
1325     # values passed in non-primitive argument slots. When more than a single
1326     # overload is applicable, precedence is given according to the order of
1327     # declaration in the IDL.
1328
1329     my $name = $function->signature->name;
1330     my $conditionalString = GenerateConditionalString($function->signature);
1331     push(@implContentDecls, "#if ${conditionalString}\n\n") if $conditionalString;
1332     push(@implContentDecls, <<END);
1333 static v8::Handle<v8::Value> ${name}Callback(const v8::Arguments& args)
1334 {
1335     INC_STATS(\"DOM.$implClassName.$name\");
1336 END
1337
1338     foreach my $overload (@{$function->{overloads}}) {
1339         my $parametersCheck = GenerateFunctionParametersCheck($overload);
1340         push(@implContentDecls, "    if ($parametersCheck)\n");
1341         push(@implContentDecls, "        return ${name}$overload->{overloadIndex}Callback(args);\n");
1342     }
1343     push(@implContentDecls, <<END);
1344     V8Proxy::throwTypeError();
1345     return notHandledByInterceptor();
1346 END
1347     push(@implContentDecls, "}\n\n");
1348     push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
1349 }
1350
1351 sub GenerateFunctionCallback
1352 {
1353     my $function = shift;
1354     my $dataNode = shift;
1355     my $implClassName = shift;
1356
1357     my $interfaceName = $dataNode->name;
1358     my $name = $function->signature->name;
1359
1360     if (@{$function->{overloads}} > 1) {
1361         # Append a number to an overloaded method's name to make it unique:
1362         $name = $name . $function->{overloadIndex};
1363     }
1364
1365     # Adding and removing event listeners are not standard callback behavior,
1366     # but they are extremely consistent across the various classes that take event listeners,
1367     # so we can generate them as a "special case".
1368     if ($name eq "addEventListener") {
1369         GenerateEventListenerCallback($implClassName, !IsNodeSubType($dataNode), "add");
1370         return;
1371     } elsif ($name eq "removeEventListener") {
1372         GenerateEventListenerCallback($implClassName, !IsNodeSubType($dataNode), "remove");
1373         return;
1374     }
1375
1376     my $conditionalString = GenerateConditionalString($function->signature);
1377     push(@implContentDecls, "#if ${conditionalString}\n\n") if $conditionalString;
1378     push(@implContentDecls, <<END);
1379 static v8::Handle<v8::Value> ${name}Callback(const v8::Arguments& args)
1380 {
1381     INC_STATS(\"DOM.$implClassName.$name\");
1382 END
1383
1384     push(@implContentDecls, GenerateArgumentsCountCheck($function, $dataNode));
1385
1386     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($implClassName);
1387
1388     if ($svgNativeType) {
1389         my $nativeClassName = GetNativeType($implClassName); 
1390         if ($implClassName =~ /List$/) {
1391             push(@implContentDecls, "    $nativeClassName imp = V8${implClassName}::toNative(args.Holder());\n");
1392         } else {
1393             AddToImplIncludes("ExceptionCode.h");
1394             push(@implContentDecls, "    $nativeClassName wrapper = V8${implClassName}::toNative(args.Holder());\n");
1395             push(@implContentDecls, "    if (wrapper->role() == AnimValRole) {\n");
1396             push(@implContentDecls, "        V8Proxy::setDOMException(NO_MODIFICATION_ALLOWED_ERR);\n");
1397             push(@implContentDecls, "        return v8::Handle<v8::Value>();\n");
1398             push(@implContentDecls, "    }\n");
1399             my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implClassName);
1400             push(@implContentDecls, "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n");
1401             push(@implContentDecls, "    $svgWrappedNativeType* imp = &impInstance;\n");
1402         }
1403     } elsif (!$function->isStatic) {
1404         push(@implContentDecls, <<END);
1405     ${implClassName}* imp = V8${implClassName}::toNative(args.Holder());
1406 END
1407     }
1408
1409     # Check domain security if needed
1410     if (($dataNode->extendedAttributes->{"CheckSecurity"}
1411        || $interfaceName eq "DOMWindow")
1412        && !$function->signature->extendedAttributes->{"DoNotCheckSecurity"}) {
1413     # We have not find real use cases yet.
1414     push(@implContentDecls, <<END);
1415     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
1416         return v8::Handle<v8::Value>();
1417 END
1418     }
1419
1420     my $raisesExceptions = @{$function->raisesExceptions};
1421     if (!$raisesExceptions) {
1422         foreach my $parameter (@{$function->parameters}) {
1423             if ((!$parameter->extendedAttributes->{"Callback"} and TypeCanFailConversion($parameter)) or $parameter->extendedAttributes->{"IsIndex"}) {
1424                 $raisesExceptions = 1;
1425             }
1426         }
1427     }
1428
1429     if ($raisesExceptions) {
1430         AddToImplIncludes("ExceptionCode.h");
1431         push(@implContentDecls, "    ExceptionCode ec = 0;\n");
1432         push(@implContentDecls, "    {\n");
1433         # The brace here is needed to prevent the ensuing 'goto fail's from jumping past constructors
1434         # of objects (like Strings) declared later, causing compile errors. The block scope ends
1435         # right before the label 'fail:'.
1436     }
1437
1438     if ($function->signature->extendedAttributes->{"CheckSecurityForNode"}) {
1439         push(@implContentDecls, "    if (!V8BindingSecurity::shouldAllowAccessToNode(V8BindingState::Only(), imp->" . $function->signature->name . "(ec)))\n");
1440         push(@implContentDecls, "        return v8::Handle<v8::Value>(v8::Null());\n");
1441 END
1442     }
1443
1444     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $implClassName);
1445     push(@implContentDecls, $parameterCheckString);
1446
1447     # Build the function call string.
1448     push(@implContentDecls, GenerateFunctionCallString($function, $paramIndex, "    ", $implClassName, %replacements));
1449
1450     if ($raisesExceptions) {
1451         push(@implContentDecls, "    }\n");
1452         push(@implContentDecls, "    fail:\n");
1453         push(@implContentDecls, "    V8Proxy::setDOMException(ec);\n");
1454         push(@implContentDecls, "    return v8::Handle<v8::Value>();\n");
1455     }
1456
1457     push(@implContentDecls, "}\n\n");
1458     push(@implContentDecls, "#endif // ${conditionalString}\n\n") if $conditionalString;
1459 }
1460
1461 sub GenerateCallWith
1462 {
1463     my $callWith = shift;
1464     return () unless $callWith;
1465     my $outputArray = shift;
1466     my $indent = shift;
1467     my $returnVoid = shift;
1468     my $emptyContext = shift;
1469     my $function = shift;
1470
1471     my @callWithArgs;
1472     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptState")) {
1473         if ($emptyContext) {
1474             push(@$outputArray, $indent . "EmptyScriptState state;\n");
1475             push(@callWithArgs, "&state");
1476         } else {
1477             push(@$outputArray, $indent . "ScriptState* state = ScriptState::current();\n");
1478             push(@$outputArray, $indent . "if (!state)\n");
1479             push(@$outputArray, $indent . "    return" . ($returnVoid ? "" : " v8::Undefined()") . ";\n");
1480             push(@callWithArgs, "state");
1481         }
1482     }
1483     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptExecutionContext")) {
1484         push(@$outputArray, $indent . "ScriptExecutionContext* scriptContext = getScriptExecutionContext();\n");
1485         push(@$outputArray, $indent . "if (!scriptContext)\n");
1486         push(@$outputArray, $indent . "    return" . ($returnVoid ? "" : " v8::Undefined()") . ";\n");
1487         push(@callWithArgs, "scriptContext");
1488     }
1489     if ($function and $codeGenerator->ExtendedAttributeContains($callWith, "ScriptArguments")) {
1490         push(@$outputArray, $indent . "RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, " . @{$function->parameters} . "));\n");
1491         push(@callWithArgs, "scriptArguments");
1492         AddToImplIncludes("ScriptArguments.h");
1493     }
1494     if ($codeGenerator->ExtendedAttributeContains($callWith, "CallStack")) {
1495         push(@$outputArray, $indent . "RefPtr<ScriptCallStack> callStack(createScriptCallStackForInspector());\n");
1496         push(@$outputArray, $indent . "if (!callStack)\n");
1497         push(@$outputArray, $indent . "    return v8::Undefined();\n");
1498         push(@callWithArgs, "callStack");
1499         AddToImplIncludes("ScriptCallStack.h");
1500         AddToImplIncludes("ScriptCallStackFactory.h");
1501     }
1502     return @callWithArgs;
1503 }
1504
1505 sub GenerateArgumentsCountCheck
1506 {
1507     my $function = shift;
1508     my $dataNode = shift;
1509
1510     my $numMandatoryParams = 0;
1511     my $optionalSeen = 0;
1512     foreach my $param (@{$function->parameters}) {
1513         if ($param->extendedAttributes->{"Optional"}) {
1514             $optionalSeen = 1;
1515         } else {
1516             die "An argument must not be declared to be optional unless all subsequent arguments to the operation are also optional." if $optionalSeen;
1517             $numMandatoryParams++;
1518         }
1519     }
1520
1521     my $argumentsCountCheckString = "";
1522     if ($numMandatoryParams >= 1) {
1523         $argumentsCountCheckString .= "    if (args.Length() < $numMandatoryParams)\n";
1524         $argumentsCountCheckString .= "        return throwError(\"Not enough arguments\", V8Proxy::TypeError);\n";
1525     }
1526     return $argumentsCountCheckString;
1527 }
1528
1529 sub GetIndexOf
1530 {
1531     my $paramName = shift;
1532     my @paramList = @_;
1533     my $index = 0;
1534     foreach my $param (@paramList) {
1535         if ($paramName eq $param) {
1536             return $index;
1537         }
1538         $index++;
1539     }
1540     return -1;
1541 }
1542
1543 sub GenerateParametersCheck
1544 {
1545     my $function = shift;
1546     my $implClassName = shift;
1547
1548     my $parameterCheckString = "";
1549     my $paramIndex = 0;
1550     my @paramTransferListNames = ();
1551     my %replacements = ();
1552
1553     foreach my $parameter (@{$function->parameters}) {
1554         TranslateParameter($parameter);
1555
1556         my $parameterName = $parameter->name;
1557
1558         # Optional arguments with [Optional] should generate an early call with fewer arguments.
1559         # Optional arguments with [Optional=...] should not generate the early call.
1560         my $optional = $parameter->extendedAttributes->{"Optional"};
1561         if ($optional && $optional ne "DefaultIsUndefined" && $optional ne "DefaultIsNullString" && !$parameter->extendedAttributes->{"Callback"}) {
1562             $parameterCheckString .= "    if (args.Length() <= $paramIndex) {\n";
1563             my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $implClassName, %replacements);
1564             $parameterCheckString .= $functionCall;
1565             $parameterCheckString .= "    }\n";
1566         }
1567
1568         my $parameterDefaultPolicy = "DefaultIsUndefined";
1569         if ($optional and $optional eq "DefaultIsNullString") {
1570             $parameterDefaultPolicy = "DefaultIsNullString";
1571         }
1572
1573         if (GetIndexOf($parameterName, @paramTransferListNames) != -1) {
1574             $replacements{$parameterName} = "messagePortArray" . ucfirst($parameterName);
1575             $paramIndex++;
1576             next;
1577         }
1578
1579         AddToImplIncludes("ExceptionCode.h");
1580         my $nativeType = GetNativeTypeFromSignature($parameter, $paramIndex);
1581         if ($parameter->extendedAttributes->{"Callback"}) {
1582             my $className = GetCallbackClassName($parameter->type);
1583             AddToImplIncludes("$className.h");
1584             if ($optional) {
1585                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
1586                 $parameterCheckString .= "    if (args.Length() > $paramIndex && !args[$paramIndex]->IsNull() && !args[$paramIndex]->IsUndefined()) {\n";
1587                 $parameterCheckString .= "        if (!args[$paramIndex]->IsObject())\n";
1588                 $parameterCheckString .= "            return throwError(TYPE_MISMATCH_ERR);\n";
1589                 $parameterCheckString .= "        $parameterName = ${className}::create(args[$paramIndex], getScriptExecutionContext());\n";
1590                 $parameterCheckString .= "    }\n";
1591             } else {
1592                 $parameterCheckString .= "    if (args.Length() <= $paramIndex || !args[$paramIndex]->IsObject())\n";
1593                 $parameterCheckString .= "        return throwError(TYPE_MISMATCH_ERR);\n";
1594                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ${className}::create(args[$paramIndex], getScriptExecutionContext());\n";
1595             }
1596         } elsif ($parameter->type eq "SerializedScriptValue") {
1597             AddToImplIncludes("SerializedScriptValue.h");
1598             my $useTransferList = 0;
1599             my $transferListName = "";
1600             my $TransferListName = "";
1601             if ($parameter->extendedAttributes->{"TransferList"}) {
1602                 $transferListName = $parameter->extendedAttributes->{"TransferList"};
1603                 push(@paramTransferListNames, $transferListName);
1604
1605                 my @allParameterNames = ();
1606                 foreach my $parameter (@{$function->parameters}) {
1607                     push(@allParameterNames, $parameter->name);
1608                 }
1609                 my $transferListIndex = GetIndexOf($transferListName, @allParameterNames);
1610                 if ($transferListIndex == -1) {
1611                     die "IDL error: TransferList refers to a nonexistent argument";
1612                 }
1613
1614                 AddToImplIncludes("ArrayBuffer.h");
1615                 AddToImplIncludes("MessagePort.h");
1616                 $TransferListName = ucfirst($transferListName);
1617                 $parameterCheckString .= "    MessagePortArray messagePortArray$TransferListName;\n";
1618                 $parameterCheckString .= "    ArrayBufferArray arrayBufferArray$TransferListName;\n";
1619                 $parameterCheckString .= "    if (args.Length() > $transferListIndex) {\n";
1620                 $parameterCheckString .= "        if (!extractTransferables(args[$transferListIndex], messagePortArray$TransferListName, arrayBufferArray$TransferListName))\n";
1621                 $parameterCheckString .= "            return throwError(\"Could not extract transferables\", V8Proxy::TypeError);\n";
1622                 $parameterCheckString .= "    }\n";
1623                 $useTransferList = 1;
1624             }
1625             $parameterCheckString .= "    bool ${parameterName}DidThrow = false;\n";
1626             if (!$useTransferList) {
1627                     $parameterCheckString .= "    $nativeType $parameterName = SerializedScriptValue::create(args[$paramIndex], 0, 0, ${parameterName}DidThrow);\n";
1628             } else {
1629                     $parameterCheckString .= "    $nativeType $parameterName = SerializedScriptValue::create(args[$paramIndex], &messagePortArray$TransferListName, &arrayBufferArray$TransferListName, ${parameterName}DidThrow);\n";
1630             }
1631             $parameterCheckString .= "    if (${parameterName}DidThrow)\n";
1632             $parameterCheckString .= "        return v8::Undefined();\n";
1633         } elsif (TypeCanFailConversion($parameter)) {
1634             $parameterCheckString .= "    $nativeType $parameterName = " .
1635                  JSValueToNative($parameter, "args[$paramIndex]") . ";\n";
1636             $parameterCheckString .= "    if (UNLIKELY(!$parameterName)) {\n";
1637             $parameterCheckString .= "        ec = TYPE_MISMATCH_ERR;\n";
1638             $parameterCheckString .= "        goto fail;\n";
1639             $parameterCheckString .= "    }\n";
1640         } elsif ($nativeType =~ /^V8Parameter/) {
1641             my $value = JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterDefaultPolicy)");
1642             $parameterCheckString .= "    " . ConvertToV8Parameter($parameter, $nativeType, $parameterName, $value) . "\n";
1643         } else {
1644             AddToImplIncludes("V8BindingMacros.h");
1645             # If the "StrictTypeChecking" extended attribute is present, and the argument's type is an
1646             # interface type, then if the incoming value does not implement that interface, a TypeError
1647             # is thrown rather than silently passing NULL to the C++ code.
1648             # Per the Web IDL and ECMAScript specifications, incoming values can always be converted
1649             # to both strings and numbers, so do not throw TypeError if the argument is of these
1650             # types.
1651             if ($function->signature->extendedAttributes->{"StrictTypeChecking"}) {
1652                 my $argValue = "args[$paramIndex]";
1653                 my $argType = GetTypeFromSignature($parameter);
1654                 if (IsWrapperType($argType)) {
1655                     $parameterCheckString .= "    if (args.Length() > $paramIndex && !isUndefinedOrNull($argValue) && !V8${argType}::HasInstance($argValue)) {\n";
1656                     $parameterCheckString .= "        V8Proxy::throwTypeError();\n";
1657                     $parameterCheckString .= "        return notHandledByInterceptor();\n";
1658                     $parameterCheckString .= "    }\n";
1659                 }
1660             }
1661             $parameterCheckString .= "    EXCEPTION_BLOCK($nativeType, $parameterName, " .
1662                  JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterDefaultPolicy)") . ");\n";
1663             if ($nativeType eq 'Dictionary') {
1664                $parameterCheckString .= "    if (args.Length() > $paramIndex && !$parameterName.isUndefinedOrNull() && !$parameterName.isObject()) {\n";
1665                $parameterCheckString .= "        ec = TYPE_MISMATCH_ERR;\n";
1666                $parameterCheckString .= "        V8Proxy::setDOMException(ec);\n";
1667                $parameterCheckString .= "        return throwError(\"Not an object.\", V8Proxy::TypeError);\n";
1668                $parameterCheckString .= "    }\n";
1669             }
1670         }
1671
1672         if ($parameter->extendedAttributes->{"IsIndex"}) {
1673             $parameterCheckString .= "    if (UNLIKELY($parameterName < 0)) {\n";
1674             $parameterCheckString .= "        ec = INDEX_SIZE_ERR;\n";
1675             $parameterCheckString .= "        goto fail;\n";
1676             $parameterCheckString .= "    }\n";
1677         }
1678
1679         $paramIndex++;
1680     }
1681     return ($parameterCheckString, $paramIndex, %replacements);
1682 }
1683
1684 sub GenerateConstructorCallback
1685 {
1686     my $function = shift;
1687     my $dataNode = shift;
1688     my $implClassName = shift;
1689
1690     my $raisesExceptions = @{$function->raisesExceptions};
1691     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1692         $raisesExceptions = 1;
1693     }
1694     if (!$raisesExceptions) {
1695         foreach my $parameter (@{$function->parameters}) {
1696             if ((!$parameter->extendedAttributes->{"Callback"} and TypeCanFailConversion($parameter)) or $parameter->extendedAttributes->{"IsIndex"}) {
1697                 $raisesExceptions = 1;
1698             }
1699         }
1700     }
1701
1702     my @beforeArgumentList;
1703     my @afterArgumentList;
1704     push(@implContent, <<END);
1705 v8::Handle<v8::Value> V8${implClassName}::constructorCallback(const v8::Arguments& args)
1706 {
1707     INC_STATS("DOM.${implClassName}.Constructor");
1708
1709     if (!args.IsConstructCall())
1710         return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);
1711
1712     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
1713         return args.Holder();
1714 END
1715
1716     push(@implContent, GenerateArgumentsCountCheck($function, $dataNode));
1717
1718     if ($raisesExceptions) {
1719         AddToImplIncludes("ExceptionCode.h");
1720         push(@implContent, "\n");
1721         push(@implContent, "    ExceptionCode ec = 0;\n");
1722     }
1723
1724     # FIXME: Currently [Constructor(...)] does not yet support [Optional] arguments.
1725     # It just supports [Optional=DefaultIsUndefined] or [Optional=DefaultIsNullString].
1726     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $implClassName);
1727     push(@implContent, $parameterCheckString);
1728
1729     if ($dataNode->extendedAttributes->{"CallWith"} && $dataNode->extendedAttributes->{"CallWith"} eq "ScriptExecutionContext") {
1730         push(@beforeArgumentList, "context");
1731         push(@implContent, <<END);
1732
1733     ScriptExecutionContext* context = getScriptExecutionContext();
1734     if (!context)
1735         return throwError("${implClassName} constructor's associated context is not available", V8Proxy::ReferenceError);
1736 END
1737     }
1738
1739     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1740         push(@afterArgumentList, "ec");
1741     }
1742
1743     my @argumentList;
1744     my $index = 0;
1745     foreach my $parameter (@{$function->parameters}) {
1746         last if $index eq $paramIndex;
1747         if ($replacements{$parameter->name}) {
1748             push(@argumentList, $replacements{$parameter->name});
1749         } else {
1750             push(@argumentList, $parameter->name);
1751         }
1752         $index++;
1753     }
1754
1755     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
1756     push(@implContent, "\n");
1757     push(@implContent, "    RefPtr<${implClassName}> impl = ${implClassName}::create(${argumentString});\n");
1758     push(@implContent, "    v8::Handle<v8::Object> wrapper = args.Holder();\n");
1759
1760     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1761         push(@implContent, "    if (ec)\n");
1762         push(@implContent, "        goto fail;\n");
1763     }
1764
1765     my $DOMObject = "DOMObject";
1766     if (IsNodeSubType($dataNode)) {
1767         $DOMObject = "DOMNode";
1768     } elsif ($dataNode->extendedAttributes->{"ActiveDOMObject"}) {
1769         $DOMObject = "ActiveDOMObject";
1770     }
1771
1772     push(@implContent, <<END);
1773
1774     V8DOMWrapper::setDOMWrapper(wrapper, &info, impl.get());
1775     impl->ref();
1776     V8DOMWrapper::setJSWrapperFor${DOMObject}(impl.get(), v8::Persistent<v8::Object>::New(wrapper));
1777     return args.Holder();
1778 END
1779
1780     if ($raisesExceptions) {
1781         push(@implContent, "  fail:\n");
1782         push(@implContent, "    return throwError(ec);\n");
1783     }
1784
1785     push(@implContent, "}\n");
1786     push(@implContent, "\n");
1787 }
1788
1789 sub GenerateEventConstructorCallback
1790 {
1791     my $dataNode = shift;
1792     my $implClassName = shift;
1793
1794     AddToImplIncludes("Dictionary.h");
1795     AddToImplIncludes("V8BindingMacros.h");
1796     push(@implContent, <<END);
1797 v8::Handle<v8::Value> V8${implClassName}::constructorCallback(const v8::Arguments& args)
1798 {
1799     INC_STATS("DOM.${implClassName}.Constructor");
1800
1801     if (!args.IsConstructCall())
1802         return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);
1803
1804     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
1805         return args.Holder();
1806
1807     if (args.Length() < 1)
1808         return throwError("Not enough arguments", V8Proxy::TypeError);
1809
1810     STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, type, args[0]);
1811     ${implClassName}Init eventInit;
1812     if (args.Length() >= 2) {
1813         EXCEPTION_BLOCK(Dictionary, options, args[1]);
1814         if (!fill${implClassName}Init(eventInit, options))
1815             return v8::Undefined();
1816     }
1817
1818     RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit);
1819
1820     V8DOMWrapper::setDOMWrapper(args.Holder(), &info, event.get());
1821     return toV8(event.release(), args.Holder());
1822 }
1823
1824 bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
1825 {
1826 END
1827
1828     foreach my $interfaceBase (@{$dataNode->parents}) {
1829         push(@implContent, <<END);
1830     if (!fill${interfaceBase}Init(eventInit, options))
1831         return false;
1832
1833 END
1834     }
1835
1836     for (my $index = 0; $index < @{$dataNode->attributes}; $index++) {
1837         my $attribute = @{$dataNode->attributes}[$index];
1838         if ($attribute->signature->extendedAttributes->{"InitializedByEventConstructor"}) {
1839             my $attributeName = $attribute->signature->name;
1840             push(@implContent, "    options.get(\"$attributeName\", eventInit.$attributeName);\n");
1841         }
1842     }
1843
1844     push(@implContent, <<END);
1845     return true;
1846 }
1847
1848 END
1849 }
1850
1851 sub GenerateNamedConstructorCallback
1852 {
1853     my $function = shift;
1854     my $dataNode = shift;
1855     my $implClassName = shift;
1856
1857     my $raisesExceptions = @{$function->raisesExceptions};
1858     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1859         $raisesExceptions = 1;
1860     }
1861     if (!$raisesExceptions) {
1862         foreach my $parameter (@{$function->parameters}) {
1863             if ((!$parameter->extendedAttributes->{"Callback"} and TypeCanFailConversion($parameter)) or $parameter->extendedAttributes->{"IsIndex"}) {
1864                 $raisesExceptions = 1;
1865             }
1866         }
1867     }
1868
1869     my @beforeArgumentList;
1870     my @afterArgumentList;
1871
1872     if ($dataNode->extendedAttributes->{"ActiveDOMObject"}) {
1873         push(@implContent, <<END);
1874 WrapperTypeInfo V8${implClassName}Constructor::info = { V8${implClassName}Constructor::GetTemplate, V8${implClassName}::derefObject, V8${implClassName}::toActiveDOMObject, 0 };
1875
1876 END
1877     } else {
1878         push(@implContent, <<END);
1879 WrapperTypeInfo V8${implClassName}Constructor::info = { V8${implClassName}Constructor::GetTemplate, 0, 0, 0 };
1880
1881 END
1882     }
1883
1884     push(@implContent, <<END);
1885 static v8::Handle<v8::Value> V8${implClassName}ConstructorCallback(const v8::Arguments& args)
1886 {
1887     INC_STATS("DOM.${implClassName}.Constructor");
1888
1889     if (!args.IsConstructCall())
1890         return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);
1891
1892     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
1893         return args.Holder();
1894
1895     Frame* frame = V8Proxy::retrieveFrameForCurrentContext();
1896     if (!frame)
1897         return throwError("${implClassName} constructor associated frame is unavailable", V8Proxy::ReferenceError);
1898
1899     Document* document = frame->document();
1900
1901     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
1902     // may end up being the only node in the map and get garbage-collected prematurely.
1903     toV8(document);
1904
1905 END
1906
1907     push(@implContent, GenerateArgumentsCountCheck($function, $dataNode));
1908
1909     if ($raisesExceptions) {
1910         AddToImplIncludes("ExceptionCode.h");
1911         push(@implContent, "\n");
1912         push(@implContent, "    ExceptionCode ec = 0;\n");
1913     }
1914
1915     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $implClassName);
1916     push(@implContent, $parameterCheckString);
1917
1918     push(@beforeArgumentList, "document");
1919
1920     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1921         push(@afterArgumentList, "ec");
1922     }
1923
1924     my @argumentList;
1925     my $index = 0;
1926     foreach my $parameter (@{$function->parameters}) {
1927         last if $index eq $paramIndex;
1928         if ($replacements{$parameter->name}) {
1929             push(@argumentList, $replacements{$parameter->name});
1930         } else {
1931             push(@argumentList, $parameter->name);
1932         }
1933         $index++;
1934     }
1935
1936     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
1937     push(@implContent, "\n");
1938     push(@implContent, "    RefPtr<${implClassName}> impl = ${implClassName}::createForJSConstructor(${argumentString});\n");
1939     push(@implContent, "    v8::Handle<v8::Object> wrapper = args.Holder();\n");
1940
1941     if ($dataNode->extendedAttributes->{"ConstructorRaisesException"}) {
1942         push(@implContent, "    if (ec)\n");
1943         push(@implContent, "        goto fail;\n");
1944     }
1945
1946     my $DOMObject = "DOMObject";
1947     # A DOMObject that is an ActiveDOMObject and also a DOMNode should be treated as an DOMNode here.
1948     # setJSWrapperForDOMNode() will look if node is active and choose correct map to add node to.
1949     if (IsNodeSubType($dataNode)) {
1950         $DOMObject = "DOMNode";
1951     } elsif ($dataNode->extendedAttributes->{"ActiveDOMObject"}) {
1952         $DOMObject = "ActiveDOMObject";
1953     }
1954     push(@implContent, <<END);
1955
1956     V8DOMWrapper::setDOMWrapper(wrapper, &V8${implClassName}Constructor::info, impl.get());
1957     impl->ref();
1958     V8DOMWrapper::setJSWrapperFor${DOMObject}(impl.get(), v8::Persistent<v8::Object>::New(wrapper));
1959     return args.Holder();
1960 END
1961
1962     if ($raisesExceptions) {
1963         push(@implContent, "  fail:\n");
1964         push(@implContent, "    return throwError(ec);\n");
1965     }
1966
1967     push(@implContent, "}\n");
1968
1969     push(@implContent, <<END);
1970
1971 v8::Persistent<v8::FunctionTemplate> V8${implClassName}Constructor::GetTemplate()
1972 {
1973     static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
1974     if (!cachedTemplate.IsEmpty())
1975         return cachedTemplate;
1976
1977     v8::HandleScope scope;
1978     v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(V8${implClassName}ConstructorCallback);
1979
1980     v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
1981     instance->SetInternalFieldCount(V8${implClassName}::internalFieldCount);
1982     result->SetClassName(v8::String::New("${implClassName}"));
1983     result->Inherit(V8${implClassName}::GetTemplate());
1984
1985     cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
1986     return cachedTemplate;
1987 }
1988
1989 END
1990 }
1991
1992 sub GenerateBatchedAttributeData
1993 {
1994     my $dataNode = shift;
1995     my $interfaceName = $dataNode->name;
1996     my $attributes = shift;
1997
1998     foreach my $attribute (@$attributes) {
1999         my $conditionalString = GenerateConditionalString($attribute->signature);
2000         push(@implContent, "#if ${conditionalString}\n") if $conditionalString;
2001         GenerateSingleBatchedAttribute($interfaceName, $attribute, ",", "");
2002         push(@implContent, "#endif // ${conditionalString}\n") if $conditionalString;
2003     }
2004 }
2005
2006 sub GenerateSingleBatchedAttribute
2007 {
2008     my $interfaceName = shift;
2009     my $attribute = shift;
2010     my $delimiter = shift;
2011     my $indent = shift;
2012     my $attrName = $attribute->signature->name;
2013     my $attrExt = $attribute->signature->extendedAttributes;
2014
2015     my $accessControl = "v8::DEFAULT";
2016     if ($attrExt->{"DoNotCheckSecurityOnGetter"}) {
2017         $accessControl = "v8::ALL_CAN_READ";
2018     } elsif ($attrExt->{"DoNotCheckSecurityOnSetter"}) {
2019         $accessControl = "v8::ALL_CAN_WRITE";
2020     } elsif ($attrExt->{"DoNotCheckSecurity"}) {
2021         $accessControl = "v8::ALL_CAN_READ";
2022         if (!($attribute->type =~ /^readonly/) && !($attrExt->{"V8ReadOnly"})) {
2023             $accessControl .= " | v8::ALL_CAN_WRITE";
2024         }
2025     }
2026     if ($attrExt->{"V8Unforgeable"}) {
2027         $accessControl .= " | v8::PROHIBITS_OVERWRITING";
2028     }
2029     $accessControl = "static_cast<v8::AccessControl>(" . $accessControl . ")";
2030
2031     my $customAccessor =
2032         $attrExt->{"Custom"} ||
2033         $attrExt->{"CustomSetter"} ||
2034         $attrExt->{"CustomGetter"} ||
2035         $attrExt->{"V8Custom"} ||
2036         $attrExt->{"V8CustomSetter"} ||
2037         $attrExt->{"V8CustomGetter"} ||
2038         "";
2039     if ($customAccessor eq "VALUE_IS_MISSING") {
2040         # use the naming convension, interface + (capitalize) attr name
2041         $customAccessor = $interfaceName . "::" . $attrName;
2042     }
2043
2044     my $getter;
2045     my $setter;
2046     my $propAttr = "v8::None";
2047     my $hasCustomSetter = 0;
2048
2049     # Check attributes.
2050     if ($attrExt->{"NotEnumerable"}) {
2051         $propAttr .= " | v8::DontEnum";
2052     }
2053     if ($attrExt->{"V8Unforgeable"}) {
2054         $propAttr .= " | v8::DontDelete";
2055     }
2056
2057     my $on_proto = "0 /* on instance */";
2058     my $data = "0 /* no data */";
2059
2060     # Constructor
2061     if ($attribute->signature->type =~ /Constructor$/) {
2062         my $constructorType = $codeGenerator->StripModule($attribute->signature->type);
2063         $constructorType =~ s/Constructor$//;
2064         # $constructorType ~= /Constructor$/ indicates that it is NamedConstructor.
2065         # We do not generate the header file for NamedConstructor of class XXXX,
2066         # since we generate the NamedConstructor declaration into the header file of class XXXX.
2067         if ($constructorType !~ /Constructor$/ || $attribute->signature->extendedAttributes->{"V8CustomConstructor"} || $attribute->signature->extendedAttributes->{"CustomConstructor"}) {
2068             AddToImplIncludes("V8${constructorType}.h", $attribute->signature->extendedAttributes->{"Conditional"});
2069         }
2070         if ($customAccessor) {
2071             $getter = "V8${customAccessor}AccessorGetter";
2072         } else {
2073             $data = "&V8${constructorType}::info";
2074             $getter = "${interfaceName}Internal::${interfaceName}ConstructorGetter";
2075         }
2076         $setter = "0";
2077         $propAttr = "v8::ReadOnly";
2078
2079     } else {
2080         # Default Getter and Setter
2081         $getter = "${interfaceName}Internal::${attrName}AttrGetter";
2082         $setter = "${interfaceName}Internal::${attrName}AttrSetter";
2083
2084         # Custom Setter
2085         if ($attrExt->{"CustomSetter"} || $attrExt->{"V8CustomSetter"} || $attrExt->{"Custom"} || $attrExt->{"V8Custom"}) {
2086             $hasCustomSetter = 1;
2087             $setter = "V8${customAccessor}AccessorSetter";
2088         }
2089
2090         # Custom Getter
2091         if ($attrExt->{"CustomGetter"} || $attrExt->{"V8CustomGetter"} || $attrExt->{"Custom"} || $attrExt->{"V8Custom"}) {
2092             $getter = "V8${customAccessor}AccessorGetter";
2093         }
2094     }
2095
2096     # Replaceable
2097     if ($attrExt->{"Replaceable"} && !$hasCustomSetter) {
2098         $setter = "0";
2099         # Handle the special case of window.top being marked as Replaceable.
2100         # FIXME: Investigate whether we could treat window.top as replaceable
2101         # and allow shadowing without it being a security hole.
2102         if (!($interfaceName eq "DOMWindow" and $attrName eq "top")) {
2103             $propAttr .= " | v8::ReadOnly";
2104         }
2105     }
2106
2107     # Read only attributes
2108     if ($attribute->type =~ /^readonly/ || $attrExt->{"V8ReadOnly"}) {
2109         $setter = "0";
2110     }
2111
2112     # An accessor can be installed on the proto
2113     if ($attrExt->{"V8OnProto"}) {
2114         $on_proto = "1 /* on proto */";
2115     }
2116
2117     my $commentInfo = "Attribute '$attrName' (Type: '" . $attribute->type .
2118                       "' ExtAttr: '" . join(' ', keys(%{$attrExt})) . "')";
2119
2120     push(@implContent, $indent . "    \/\/ $commentInfo\n");
2121     push(@implContent, $indent . "    {\"$attrName\", $getter, $setter, $data, $accessControl, static_cast<v8::PropertyAttribute>($propAttr), $on_proto}" . $delimiter . "\n");
2122 }
2123
2124 sub GenerateImplementationIndexer
2125 {
2126     my $dataNode = shift;
2127     my $indexer = shift;
2128     my $interfaceName = $dataNode->name;
2129
2130     # FIXME: Figure out what NumericIndexedGetter is really supposed to do. Right now, it's only set on WebGL-related files.
2131     my $hasCustomSetter = $dataNode->extendedAttributes->{"CustomIndexedSetter"} && !$dataNode->extendedAttributes->{"NumericIndexedGetter"};
2132     my $hasGetter = $dataNode->extendedAttributes->{"IndexedGetter"} || $dataNode->extendedAttributes->{"CustomGetOwnPropertySlot"};
2133
2134     # FIXME: Find a way to not have to special-case HTMLOptionsCollection.
2135     if ($interfaceName eq "HTMLOptionsCollection") {
2136         $hasGetter = 1;
2137     }
2138
2139     # FIXME: Investigate and remove this nastinesss. In V8, named property handling and indexer handling are apparently decoupled,
2140     # which means that object[X] where X is a number doesn't reach named property indexer. So we need to provide
2141     # simplistic, mirrored indexer handling in addition to named property handling.
2142     my $isSpecialCase = exists $indexerSpecialCases{$interfaceName};
2143     if ($isSpecialCase) {
2144         $hasGetter = 1;
2145         if ($dataNode->extendedAttributes->{"CustomNamedSetter"}) {
2146             $hasCustomSetter = 1;
2147         }
2148     }
2149
2150     if (!$hasGetter) {
2151         return;
2152     }
2153
2154     AddToImplIncludes("V8Collection.h");
2155
2156     if (!$indexer) {
2157         $indexer = $codeGenerator->FindSuperMethod($dataNode, "item");
2158     }
2159
2160     my $indexerType = $indexer ? $indexer->type : 0;
2161
2162     # FIXME: Remove this once toV8 helper methods are implemented (see https://bugs.webkit.org/show_bug.cgi?id=32563).
2163     if ($interfaceName eq "WebKitCSSKeyframesRule") {
2164         $indexerType = "WebKitCSSKeyframeRule";
2165     }
2166
2167     if ($indexerType && !$hasCustomSetter) {
2168         if ($indexerType eq "DOMString") {
2169             my $conversion = $indexer->extendedAttributes->{"TreatReturnedNullStringAs"};
2170             if ($conversion && $conversion eq "Null") {
2171                 push(@implContent, <<END);
2172     setCollectionStringOrNullIndexedGetter<${interfaceName}>(desc);
2173 END
2174             } else {
2175                 push(@implContent, <<END);
2176     setCollectionStringIndexedGetter<${interfaceName}>(desc);
2177 END
2178             }
2179         } else {
2180             push(@implContent, <<END);
2181     setCollectionIndexedGetter<${interfaceName}, ${indexerType}>(desc);
2182 END
2183             # Include the header for this indexer type, because setCollectionIndexedGetter() requires toV8() for this type.
2184             AddToImplIncludes("V8${indexerType}.h");
2185         }
2186
2187         return;
2188     }
2189
2190     my $hasDeleter = $dataNode->extendedAttributes->{"CustomDeleteProperty"};
2191     my $hasEnumerator = !$isSpecialCase && IsNodeSubType($dataNode);
2192     my $setOn = "Instance";
2193
2194     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
2195     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
2196     # get implementation straight out of the DOMWindow prototype regardless of what prototype is actually set
2197     # on the object.
2198     if ($interfaceName eq "DOMWindow") {
2199         $setOn = "Prototype";
2200         $hasDeleter = 0;
2201     }
2202
2203     push(@implContent, "    desc->${setOn}Template()->SetIndexedPropertyHandler(V8${interfaceName}::indexedPropertyGetter");
2204     push(@implContent, $hasCustomSetter ? ", V8${interfaceName}::indexedPropertySetter" : ", 0");
2205     push(@implContent, ", 0"); # IndexedPropertyQuery -- not being used at the moment.
2206     push(@implContent, $hasDeleter ? ", V8${interfaceName}::indexedPropertyDeleter" : ", 0");
2207     push(@implContent, ", nodeCollectionIndexedPropertyEnumerator<${interfaceName}>") if $hasEnumerator;
2208     push(@implContent, ");\n");
2209 }
2210
2211 sub GenerateImplementationNamedPropertyGetter
2212 {
2213     my $dataNode = shift;
2214     my $namedPropertyGetter = shift;
2215     my $interfaceName = $dataNode->name;
2216     my $hasCustomNamedGetter = $dataNode->extendedAttributes->{"CustomNamedGetter"} || $dataNode->extendedAttributes->{"CustomGetOwnPropertySlot"};
2217
2218     # FIXME: Remove hard-coded HTMLOptionsCollection reference by changing HTMLOptionsCollection to not inherit
2219     # from HTMLCollection per W3C spec (http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109/html.html#HTMLOptionsCollection).
2220     if ($interfaceName eq "HTMLOptionsCollection") {
2221         $interfaceName = "HTMLCollection";
2222         $hasCustomNamedGetter = 1;
2223     }
2224
2225     if ($interfaceName eq "HTMLAppletElement" || $interfaceName eq "HTMLEmbedElement" || $interfaceName eq "HTMLObjectElement") {
2226         $hasCustomNamedGetter = 1;
2227     }
2228
2229     if ($interfaceName eq "HTMLDocument") {
2230         $hasCustomNamedGetter = 0;
2231     }
2232
2233     my $hasGetter = $dataNode->extendedAttributes->{"NamedGetter"} || $hasCustomNamedGetter;
2234     if (!$hasGetter) {
2235         return;
2236     }
2237
2238     if (!$namedPropertyGetter) {
2239         $namedPropertyGetter = $codeGenerator->FindSuperMethod($dataNode, "namedItem");
2240     }
2241
2242     if ($namedPropertyGetter && $namedPropertyGetter->type ne "Node" && !$namedPropertyGetter->extendedAttributes->{"Custom"} && !$hasCustomNamedGetter) {
2243         AddToImplIncludes("V8Collection.h");
2244         my $type = $namedPropertyGetter->type;
2245         push(@implContent, <<END);
2246     setCollectionNamedGetter<${interfaceName}, ${type}>(desc);
2247 END
2248         return;
2249     }
2250
2251     my $hasCustomNamedSetter = $dataNode->extendedAttributes->{"CustomNamedSetter"};
2252     my $hasDeleter = $dataNode->extendedAttributes->{"CustomDeleteProperty"};
2253     my $hasEnumerator = $dataNode->extendedAttributes->{"CustomEnumerateProperty"};
2254     my $setOn = "Instance";
2255
2256     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
2257     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
2258     # get implementation straight out of the DOMWindow prototype regardless of what prototype is actually set
2259     # on the object.
2260     if ($interfaceName eq "DOMWindow") {
2261         $setOn = "Prototype";
2262         $hasDeleter = 0;
2263         $hasEnumerator = 0;
2264     }
2265
2266     push(@implContent, "    desc->${setOn}Template()->SetNamedPropertyHandler(V8${interfaceName}::namedPropertyGetter, ");
2267     push(@implContent, $hasCustomNamedSetter ? "V8${interfaceName}::namedPropertySetter, " : "0, ");
2268     # If there is a custom enumerator, there MUST be custom query to properly communicate property attributes.
2269     push(@implContent, $hasEnumerator ? "V8${interfaceName}::namedPropertyQuery, " : "0, ");
2270     push(@implContent, $hasDeleter ? "V8${interfaceName}::namedPropertyDeleter, " : "0, ");
2271     push(@implContent, $hasEnumerator ? "V8${interfaceName}::namedPropertyEnumerator" : "0");
2272     push(@implContent, ");\n");
2273 }
2274
2275 sub GenerateImplementationCustomCall
2276 {
2277     my $dataNode = shift;
2278     my $interfaceName = $dataNode->name;
2279     my $hasCustomCall = $dataNode->extendedAttributes->{"CustomCall"};
2280
2281     if ($hasCustomCall) {
2282         push(@implContent, "    desc->InstanceTemplate()->SetCallAsFunctionHandler(V8${interfaceName}::callAsFunctionCallback);\n");
2283     }
2284 }
2285
2286 sub GenerateImplementationMasqueradesAsUndefined
2287 {
2288     my $dataNode = shift;
2289     if ($dataNode->extendedAttributes->{"MasqueradesAsUndefined"})
2290     {
2291         push(@implContent, "    desc->InstanceTemplate()->MarkAsUndetectable();\n");
2292     }
2293 }
2294
2295 sub IsTypedArrayType
2296 {
2297     my $type = shift;
2298     return 1 if (($type eq "ArrayBuffer") or ($type eq "ArrayBufferView"));
2299     return 1 if (($type eq "Uint8Array") or ($type eq "Uint8ClampedArray") or ($type eq "Uint16Array") or ($type eq "Uint32Array"));
2300     return 1 if (($type eq "Int8Array") or ($type eq "Int16Array") or ($type eq "Int32Array"));
2301     return 1 if (($type eq "Float32Array") or ($type eq "Float64Array"));
2302     return 0;
2303 }
2304
2305
2306 sub GenerateImplementation
2307 {
2308     my $object = shift;
2309     my $dataNode = shift;
2310     my $interfaceName = $dataNode->name;
2311     my $visibleInterfaceName = $codeGenerator->GetVisibleInterfaceName($dataNode);
2312     my $className = "V8$interfaceName";
2313     my $implClassName = $interfaceName;
2314
2315     # - Add default header template
2316     push(@implFixedHeader, GenerateImplementationContentHeader($dataNode));
2317          
2318     AddToImplIncludes("RuntimeEnabledFeatures.h");
2319     AddToImplIncludes("V8Proxy.h");
2320     AddToImplIncludes("V8Binding.h");
2321     AddToImplIncludes("V8BindingState.h");
2322     AddToImplIncludes("V8DOMWrapper.h");
2323     AddToImplIncludes("V8IsolatedContext.h");
2324
2325     AddIncludesForType($interfaceName);
2326
2327     my $toActive = $dataNode->extendedAttributes->{"ActiveDOMObject"} ? "${className}::toActiveDOMObject" : "0";
2328
2329     # Find the super descriptor.
2330     my $parentClass = "";
2331     my $parentClassTemplate = "";
2332     foreach (@{$dataNode->parents}) {
2333         my $parent = $codeGenerator->StripModule($_);
2334         if ($parent eq "EventTarget") {
2335             next;
2336         }
2337         AddToImplIncludes("V8${parent}.h");
2338         $parentClass = "V8" . $parent;
2339         $parentClassTemplate = $parentClass . "::GetTemplate()";
2340         last;
2341     }
2342     push(@implContentDecls, "namespace WebCore {\n\n");
2343     my $parentClassInfo = $parentClass ? "&${parentClass}::info" : "0";
2344     push(@implContentDecls, "WrapperTypeInfo ${className}::info = { ${className}::GetTemplate, ${className}::derefObject, ${toActive}, ${parentClassInfo} };\n\n");   
2345     push(@implContentDecls, "namespace ${interfaceName}Internal {\n\n");
2346     push(@implContentDecls, "template <typename T> void V8_USE(T) { }\n\n");
2347
2348     my $hasConstructors = 0;
2349     # Generate property accessors for attributes.
2350     for (my $index = 0; $index < @{$dataNode->attributes}; $index++) {
2351         my $attribute = @{$dataNode->attributes}[$index];
2352         my $attrType = $attribute->signature->type;
2353
2354         # Generate special code for the constructor attributes.
2355         if ($attrType =~ /Constructor$/) {
2356             if (!($attribute->signature->extendedAttributes->{"CustomGetter"} ||
2357                 $attribute->signature->extendedAttributes->{"V8CustomGetter"})) {
2358                 $hasConstructors = 1;
2359             }
2360             next;
2361         }
2362
2363         if ($attrType eq "EventListener" && $interfaceName eq "DOMWindow") {
2364             $attribute->signature->extendedAttributes->{"V8OnProto"} = 1;
2365         }
2366
2367         if ($attrType eq "SerializedScriptValue") {
2368             AddToImplIncludes("SerializedScriptValue.h");
2369         }
2370
2371         # Do not generate accessor if this is a custom attribute.  The
2372         # call will be forwarded to a hand-written accessor
2373         # implementation.
2374         if ($attribute->signature->extendedAttributes->{"Custom"} ||
2375             $attribute->signature->extendedAttributes->{"V8Custom"}) {
2376             next;
2377         }
2378
2379         # Generate the accessor.
2380         if (!($attribute->signature->extendedAttributes->{"CustomGetter"} ||
2381             $attribute->signature->extendedAttributes->{"V8CustomGetter"})) {
2382             GenerateNormalAttrGetter($attribute, $dataNode, $implClassName, $interfaceName);
2383         }
2384         if (!$attribute->signature->extendedAttributes->{"CustomSetter"} &&
2385             !$attribute->signature->extendedAttributes->{"V8CustomSetter"} &&
2386             !$attribute->signature->extendedAttributes->{"Replaceable"} &&
2387             $attribute->type !~ /^readonly/ &&
2388             !$attribute->signature->extendedAttributes->{"V8ReadOnly"}) {
2389             GenerateNormalAttrSetter($attribute, $dataNode, $implClassName, $interfaceName);
2390         }
2391     }
2392
2393     if ($hasConstructors) {
2394         GenerateConstructorGetter($dataNode, $implClassName);
2395     }
2396
2397     my $indexer;
2398     my $namedPropertyGetter;
2399     # Generate methods for functions.
2400     foreach my $function (@{$dataNode->functions}) {
2401         my $isCustom = $function->signature->extendedAttributes->{"Custom"} || $function->signature->extendedAttributes->{"V8Custom"};
2402         if (!$isCustom) {
2403             GenerateFunctionCallback($function, $dataNode, $implClassName);
2404             if ($function->{overloadIndex} > 1 && $function->{overloadIndex} == @{$function->{overloads}}) {
2405                 GenerateOverloadedFunctionCallback($function, $dataNode, $implClassName);
2406             }
2407         }
2408
2409         if ($function->signature->name eq "item") {
2410             $indexer = $function->signature;
2411         }
2412
2413         if ($function->signature->name eq "namedItem") {
2414             $namedPropertyGetter = $function->signature;
2415         }
2416
2417         # If the function does not need domain security check, we need to
2418         # generate an access getter that returns different function objects
2419         # for different calling context.
2420         if (($dataNode->extendedAttributes->{"CheckSecurity"} || ($interfaceName eq "DOMWindow")) && $function->signature->extendedAttributes->{"DoNotCheckSecurity"}) {
2421             if (!$isCustom || $function->{overloadIndex} == 1) {
2422                 GenerateDomainSafeFunctionGetter($function, $implClassName);
2423             }
2424         }
2425     }
2426
2427     # Attributes
2428     my $attributes = $dataNode->attributes;
2429
2430     # For the DOMWindow interface we partition the attributes into the
2431     # ones that disallows shadowing and the rest.
2432     my @disallowsShadowing;
2433     # Also separate out attributes that are enabled at runtime so we can process them specially.
2434     my @enabledAtRuntime;
2435     my @normal;
2436     foreach my $attribute (@$attributes) {
2437
2438         if ($interfaceName eq "DOMWindow" && $attribute->signature->extendedAttributes->{"V8Unforgeable"}) {
2439             push(@disallowsShadowing, $attribute);
2440         } elsif ($attribute->signature->extendedAttributes->{"V8EnabledAtRuntime"}) {
2441             push(@enabledAtRuntime, $attribute);
2442         } else {
2443             push(@normal, $attribute);
2444         }
2445     }
2446     $attributes = \@normal;
2447     # Put the attributes that disallow shadowing on the shadow object.
2448     if (@disallowsShadowing) {
2449         push(@implContent, "static const BatchedAttribute shadowAttrs[] = {\n");
2450         GenerateBatchedAttributeData($dataNode, \@disallowsShadowing);
2451         push(@implContent, "};\n\n");
2452     }
2453
2454     my $has_attributes = 0;
2455     if (@$attributes) {
2456         $has_attributes = 1;
2457         push(@implContent, "static const BatchedAttribute ${interfaceName}Attrs[] = {\n");
2458         GenerateBatchedAttributeData($dataNode, $attributes);
2459         push(@implContent, "};\n\n");
2460     }
2461
2462     # Setup table of standard callback functions
2463     my $num_callbacks = 0;
2464     my $has_callbacks = 0;
2465     foreach my $function (@{$dataNode->functions}) {
2466         # Only one table entry is needed for overloaded methods:
2467         next if $function->{overloadIndex} > 1;
2468
2469         my $attrExt = $function->signature->extendedAttributes;
2470         # Don't put any nonstandard functions into this table:
2471         if ($attrExt->{"V8Unforgeable"}) {
2472             next;
2473         }
2474         if ($function->isStatic) {
2475             next;
2476         }
2477         if ($attrExt->{"V8EnabledAtRuntime"} || RequiresCustomSignature($function) || $attrExt->{"V8DoNotCheckSignature"}) {
2478             next;
2479         }
2480         if ($attrExt->{"DoNotCheckSecurity"} &&
2481             ($dataNode->extendedAttributes->{"CheckSecurity"} || $interfaceName eq "DOMWindow")) {
2482             next;
2483         }
2484         if ($attrExt->{"NotEnumerable"} || $attrExt->{"V8ReadOnly"}) {
2485             next;
2486         }
2487         if (!$has_callbacks) {
2488             $has_callbacks = 1;
2489             push(@implContent, "static const BatchedCallback ${interfaceName}Callbacks[] = {\n");
2490         }
2491         my $name = $function->signature->name;
2492         my $callback = GetFunctionTemplateCallbackName($function, $interfaceName);
2493         my $conditionalString = GenerateConditionalString($function->signature);
2494         push(@implContent, "#if ${conditionalString}\n") if $conditionalString;
2495         push(@implContent, <<END);
2496     {"$name", $callback},
2497 END
2498         push(@implContent, "#endif\n") if $conditionalString;
2499         $num_callbacks++;
2500     }
2501     push(@implContent, "};\n\n")  if $has_callbacks;
2502
2503     # Setup constants
2504     my $has_constants = 0;
2505     my @constantsEnabledAtRuntime;
2506     if (@{$dataNode->constants}) {
2507         $has_constants = 1;
2508         push(@implContent, "static const BatchedConstant ${interfaceName}Consts[] = {\n");
2509     }
2510     foreach my $constant (@{$dataNode->constants}) {
2511         my $name = $constant->name;
2512         my $value = $constant->value;
2513         my $attrExt = $constant->extendedAttributes;
2514         my $conditional = $attrExt->{"Conditional"};
2515         my $implementedBy = $attrExt->{"ImplementedBy"};
2516         if ($implementedBy) {
2517             AddToImplIncludes("${implementedBy}.h");
2518         }
2519         if ($attrExt->{"V8EnabledAtRuntime"}) {
2520             push(@constantsEnabledAtRuntime, $constant);
2521         } else {
2522             # FIXME: we need the static_cast here only because of one constant, NodeFilter.idl
2523             # defines "const unsigned long SHOW_ALL = 0xFFFFFFFF".  It would be better if we
2524             # handled this here, and converted it to a -1 constant in the c++ output.
2525             if ($conditional) {
2526                 my $conditionalString = $codeGenerator->GenerateConditionalStringFromAttributeValue($conditional);
2527                 push(@implContent, "#if ${conditionalString}\n");
2528             }
2529             push(@implContent, <<END);
2530     {"${name}", static_cast<signed int>($value)},
2531 END
2532             push(@implContent, "#endif\n") if $conditional;
2533         }
2534     }
2535     if ($has_constants) {
2536         push(@implContent, "};\n\n");
2537         push(@implContent, $codeGenerator->GenerateCompileTimeCheckForEnumsIfNeeded($dataNode));
2538     }
2539
2540     push(@implContentDecls, "} // namespace ${interfaceName}Internal\n\n");
2541
2542     if ($dataNode->extendedAttributes->{"NamedConstructor"} && !($dataNode->extendedAttributes->{"V8CustomConstructor"} || $dataNode->extendedAttributes->{"CustomConstructor"})) {
2543         GenerateNamedConstructorCallback($dataNode->constructor, $dataNode, $interfaceName);
2544     } elsif ($dataNode->extendedAttributes->{"Constructor"} && !($dataNode->extendedAttributes->{"V8CustomConstructor"} || $dataNode->extendedAttributes->{"CustomConstructor"})) {
2545         GenerateConstructorCallback($dataNode->constructor, $dataNode, $interfaceName);
2546     } elsif (IsConstructorTemplate($dataNode, "Event")) {
2547         GenerateEventConstructorCallback($dataNode, $interfaceName);
2548     }
2549
2550     my $access_check = "";
2551     if ($dataNode->extendedAttributes->{"CheckSecurity"} && !($interfaceName eq "DOMWindow")) {
2552         $access_check = "instance->SetAccessCheckCallbacks(V8${interfaceName}::namedSecurityCheck, V8${interfaceName}::indexedSecurityCheck, v8::External::Wrap(&V8${interfaceName}::info));";
2553     }
2554
2555     # For the DOMWindow interface, generate the shadow object template
2556     # configuration method.
2557     if ($implClassName eq "DOMWindow") {
2558         push(@implContent, <<END);
2559 static v8::Persistent<v8::ObjectTemplate> ConfigureShadowObjectTemplate(v8::Persistent<v8::ObjectTemplate> templ)
2560 {
2561     batchConfigureAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttrs, WTF_ARRAY_LENGTH(shadowAttrs));
2562
2563     // Install a security handler with V8.
2564     templ->SetAccessCheckCallbacks(V8DOMWindow::namedSecurityCheck, V8DOMWindow::indexedSecurityCheck, v8::External::Wrap(&V8DOMWindow::info));
2565     templ->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
2566     return templ;
2567 }
2568 END
2569     }
2570
2571     if (!$parentClassTemplate) {
2572         $parentClassTemplate = "v8::Persistent<v8::FunctionTemplate>()";
2573     }
2574
2575     # Generate the template configuration method
2576     push(@implContent,  <<END);
2577 static v8::Persistent<v8::FunctionTemplate> Configure${className}Template(v8::Persistent<v8::FunctionTemplate> desc)
2578 {
2579     desc->ReadOnlyPrototype();
2580
2581     v8::Local<v8::Signature> defaultSignature;
2582 END
2583     if ($dataNode->extendedAttributes->{"V8EnabledAtRuntime"}) {
2584         my $enable_function = GetRuntimeEnableFunctionName($dataNode);
2585         push(@implContent, <<END);
2586     if (!${enable_function}())
2587         defaultSignature = configureTemplate(desc, \"\", $parentClassTemplate, V8${interfaceName}::internalFieldCount, 0, 0, 0, 0);
2588     else
2589 END
2590     }
2591     push(@implContent,  <<END);
2592     defaultSignature = configureTemplate(desc, \"${visibleInterfaceName}\", $parentClassTemplate, V8${interfaceName}::internalFieldCount,
2593 END
2594     # Set up our attributes if we have them
2595     if ($has_attributes) {
2596         push(@implContent, <<END);
2597         ${interfaceName}Attrs, WTF_ARRAY_LENGTH(${interfaceName}Attrs),
2598 END
2599     } else {
2600         push(@implContent, <<END);
2601         0, 0,
2602 END
2603     }
2604
2605     if ($has_callbacks) {
2606         push(@implContent, <<END);
2607         ${interfaceName}Callbacks, WTF_ARRAY_LENGTH(${interfaceName}Callbacks));
2608 END
2609     } else {
2610         push(@implContent, <<END);
2611         0, 0);
2612 END
2613     }
2614     
2615     AddToImplIncludes("wtf/UnusedParam.h");
2616     push(@implContent, <<END);
2617     UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
2618 END
2619
2620     if (IsConstructable($dataNode)) {
2621         push(@implContent, <<END);
2622     desc->SetCallHandler(V8${interfaceName}::constructorCallback);
2623 END
2624     }
2625
2626     if ($access_check or @enabledAtRuntime or @{$dataNode->functions} or $has_constants) {
2627         push(@implContent,  <<END);
2628     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
2629     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
2630     UNUSED_PARAM(instance); // In some cases, it will not be used.
2631     UNUSED_PARAM(proto); // In some cases, it will not be used.
2632 END
2633     }
2634
2635     push(@implContent,  "    $access_check\n");
2636
2637     # Setup the enable-at-runtime attrs if we have them
2638     foreach my $runtime_attr (@enabledAtRuntime) {
2639         my $enable_function = GetRuntimeEnableFunctionName($runtime_attr->signature);
2640         my $conditionalString = GenerateConditionalString($runtime_attr->signature);
2641         push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
2642         push(@implContent, "    if (${enable_function}()) {\n");
2643         push(@implContent, "        static const BatchedAttribute attrData =\\\n");
2644         GenerateSingleBatchedAttribute($interfaceName, $runtime_attr, ";", "    ");
2645         push(@implContent, <<END);
2646         configureAttribute(instance, proto, attrData);
2647     }
2648 END
2649         push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
2650     }
2651
2652     # Setup the enable-at-runtime constants if we have them
2653     foreach my $runtime_const (@constantsEnabledAtRuntime) {
2654         my $enable_function = GetRuntimeEnableFunctionName($runtime_const);
2655         my $conditionalString = GenerateConditionalString($runtime_const);
2656         my $name = $runtime_const->name;
2657         my $value = $runtime_const->value;
2658         push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
2659         push(@implContent, "    if (${enable_function}()) {\n");
2660         push(@implContent, <<END);
2661         static const BatchedConstant constData = {"${name}", static_cast<signed int>(${value})};
2662         batchConfigureConstants(desc, proto, &constData, 1);
2663 END
2664         push(@implContent, "    }\n");
2665         push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
2666     }
2667
2668     GenerateImplementationIndexer($dataNode, $indexer);
2669     GenerateImplementationNamedPropertyGetter($dataNode, $namedPropertyGetter);
2670     GenerateImplementationCustomCall($dataNode);
2671     GenerateImplementationMasqueradesAsUndefined($dataNode);
2672
2673     # Define our functions with Set() or SetAccessor()
2674     my $total_functions = 0;
2675     foreach my $function (@{$dataNode->functions}) {
2676         # Only one accessor is needed for overloaded methods:
2677         next if $function->{overloadIndex} > 1;
2678
2679         $total_functions++;
2680         my $attrExt = $function->signature->extendedAttributes;
2681         my $name = $function->signature->name;
2682
2683         my $property_attributes = "v8::DontDelete";
2684         if ($attrExt->{"NotEnumerable"}) {
2685             $property_attributes .= " | v8::DontEnum";
2686         }
2687         if ($attrExt->{"V8ReadOnly"}) {
2688             $property_attributes .= " | v8::ReadOnly";
2689         }
2690
2691         my $commentInfo = "Function '$name' (ExtAttr: '" . join(' ', keys(%{$attrExt})) . "')";
2692
2693         my $template = "proto";
2694         if ($attrExt->{"V8Unforgeable"}) {
2695             $template = "instance";
2696         }
2697         if ($function->isStatic) {
2698             $template = "desc";
2699         }
2700
2701         my $conditional = "";
2702         if ($attrExt->{"V8EnabledAtRuntime"}) {
2703             # Only call Set()/SetAccessor() if this method should be enabled
2704             my $enable_function = GetRuntimeEnableFunctionName($function->signature);
2705             $conditional = "if (${enable_function}())\n        ";
2706         }
2707
2708         if ($attrExt->{"DoNotCheckSecurity"} &&
2709             ($dataNode->extendedAttributes->{"CheckSecurity"} || $interfaceName eq "DOMWindow")) {
2710             # Mark the accessor as ReadOnly and set it on the proto object so
2711             # it can be shadowed. This is really a hack to make it work.
2712             # There are several sceneria to call into the accessor:
2713             #   1) from the same domain: "window.open":
2714             #      the accessor finds the DOM wrapper in the proto chain;
2715             #   2) from the same domain: "window.__proto__.open":
2716             #      the accessor will NOT find a DOM wrapper in the prototype chain
2717             #   3) from another domain: "window.open":
2718             #      the access find the DOM wrapper in the prototype chain
2719             #   "window.__proto__.open" from another domain will fail when
2720             #   accessing '__proto__'
2721             #
2722             # The solution is very hacky and fragile, it really needs to be replaced
2723             # by a better solution.
2724             $property_attributes .= " | v8::ReadOnly";
2725             push(@implContent, <<END);
2726
2727     // $commentInfo
2728     ${conditional}$template->SetAccessor(v8::String::New("$name"), ${interfaceName}Internal::${name}AttrGetter, 0, v8::Handle<v8::Value>(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>($property_attributes));
2729 END
2730             $num_callbacks++;
2731             next;
2732         }
2733
2734         my $signature = "defaultSignature";
2735         if ($attrExt->{"V8DoNotCheckSignature"} || $function->isStatic) {
2736             $signature = "v8::Local<v8::Signature>()";
2737         }
2738
2739         if (RequiresCustomSignature($function)) {
2740             $signature = "${name}Signature";
2741             push(@implContent, "\n    // Custom Signature '$name'\n", CreateCustomSignature($function));
2742         }
2743
2744         # Normal function call is a template
2745         my $callback = GetFunctionTemplateCallbackName($function, $interfaceName);
2746
2747         if ($property_attributes eq "v8::DontDelete") {
2748             $property_attributes = "";
2749         } else {
2750             $property_attributes = ", static_cast<v8::PropertyAttribute>($property_attributes)";
2751         }
2752
2753         if ($template eq "proto" && $conditional eq "" && $signature eq "defaultSignature" && $property_attributes eq "") {
2754             # Standard type of callback, already created in the batch, so skip it here.
2755             next;
2756         }
2757
2758         my $conditionalString = GenerateConditionalString($function->signature);
2759         push(@implContent, "#if ${conditionalString}\n") if $conditionalString;
2760
2761         push(@implContent, <<END);
2762     ${conditional}$template->Set(v8::String::New("$name"), v8::FunctionTemplate::New($callback, v8::Handle<v8::Value>(), ${signature})$property_attributes);
2763 END
2764
2765         push(@implContent, "#endif // ${conditionalString}\n") if $conditionalString;
2766         $num_callbacks++;
2767     }
2768
2769     die "Wrong number of callbacks generated for $interfaceName ($num_callbacks, should be $total_functions)" if $num_callbacks != $total_functions;
2770
2771     if ($has_constants) {
2772         push(@implContent, <<END);
2773     batchConfigureConstants(desc, proto, ${interfaceName}Consts, WTF_ARRAY_LENGTH(${interfaceName}Consts));
2774 END
2775     }
2776
2777     # Special cases
2778     if ($interfaceName eq "DOMWindow") {
2779         push(@implContent, <<END);
2780
2781     proto->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
2782     desc->SetHiddenPrototype(true);
2783     instance->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
2784     // Set access check callbacks, but turned off initially.
2785     // When a context is detached from a frame, turn on the access check.
2786     // Turning on checks also invalidates inline caches of the object.
2787     instance->SetAccessCheckCallbacks(V8DOMWindow::namedSecurityCheck, V8DOMWindow::indexedSecurityCheck, v8::External::Wrap(&V8DOMWindow::info), false);
2788 END
2789     }
2790     if ($interfaceName eq "HTMLDocument") {
2791         push(@implContent, <<END);
2792     desc->SetHiddenPrototype(true);
2793 END
2794     }
2795     if ($interfaceName eq "Location") {
2796         push(@implContent, <<END);
2797
2798     // For security reasons, these functions are on the instance instead
2799     // of on the prototype object to ensure that they cannot be overwritten.
2800     instance->SetAccessor(v8::String::New("reload"), V8Location::reloadAccessorGetter, 0, v8::Handle<v8::Value>(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly));
2801     instance->SetAccessor(v8::String::New("replace"), V8Location::replaceAccessorGetter, 0, v8::Handle<v8::Value>(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly));
2802     instance->SetAccessor(v8::String::New("assign"), V8Location::assignAccessorGetter, 0, v8::Handle<v8::Value>(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly));
2803 END
2804     }
2805
2806     my $nativeType = GetNativeTypeForConversions($dataNode, $interfaceName);
2807     push(@implContent, <<END);
2808
2809     // Custom toString template
2810     desc->Set(getToStringName(), getToStringTemplate());
2811     return desc;
2812 }
2813
2814 v8::Persistent<v8::FunctionTemplate> ${className}::GetRawTemplate()
2815 {
2816     V8BindingPerIsolateData* data = V8BindingPerIsolateData::current();
2817     V8BindingPerIsolateData::TemplateMap::iterator result = data->rawTemplateMap().find(&info);
2818     if (result != data->rawTemplateMap().end())
2819         return result->second;
2820
2821     v8::HandleScope handleScope;
2822     v8::Persistent<v8::FunctionTemplate> templ = createRawTemplate();
2823     data->rawTemplateMap().add(&info, templ);
2824     return templ;
2825 }
2826
2827 v8::Persistent<v8::FunctionTemplate> ${className}::GetTemplate()
2828 {
2829     V8BindingPerIsolateData* data = V8BindingPerIsolateData::current();
2830     V8BindingPerIsolateData::TemplateMap::iterator result = data->templateMap().find(&info);
2831     if (result != data->templateMap().end())
2832         return result->second;
2833
2834     v8::HandleScope handleScope;
2835     v8::Persistent<v8::FunctionTemplate> templ =
2836         Configure${className}Template(GetRawTemplate());
2837     data->templateMap().add(&info, templ);
2838     return templ;
2839 }
2840
2841 bool ${className}::HasInstance(v8::Handle<v8::Value> value)
2842 {
2843     return GetRawTemplate()->HasInstance(value);
2844 }
2845
2846 END
2847
2848     if ($dataNode->extendedAttributes->{"ActiveDOMObject"}) {
2849         # MessagePort is handled like an active dom object even though it doesn't inherit
2850         # from ActiveDOMObject, so don't try to cast it to ActiveDOMObject.
2851         my $returnValue = $interfaceName eq "MessagePort" ? "0" : "toNative(object)";
2852         push(@implContent, <<END);
2853 ActiveDOMObject* ${className}::toActiveDOMObject(v8::Handle<v8::Object> object)
2854 {
2855     return ${returnValue};
2856 }      
2857 END
2858     }
2859
2860     if ($implClassName eq "DOMWindow") {
2861         push(@implContent, <<END);
2862 v8::Persistent<v8::ObjectTemplate> V8DOMWindow::GetShadowObjectTemplate()
2863 {
2864     static v8::Persistent<v8::ObjectTemplate> V8DOMWindowShadowObjectCache;
2865     if (V8DOMWindowShadowObjectCache.IsEmpty()) {
2866         V8DOMWindowShadowObjectCache = v8::Persistent<v8::ObjectTemplate>::New(v8::ObjectTemplate::New());
2867         ConfigureShadowObjectTemplate(V8DOMWindowShadowObjectCache);
2868     }
2869     return V8DOMWindowShadowObjectCache;
2870 }
2871 END
2872     }
2873
2874     GenerateToV8Converters($dataNode, $interfaceName, $className, $nativeType);
2875
2876     push(@implContent, <<END);
2877
2878 void ${className}::derefObject(void* object)
2879 {
2880 END
2881
2882     if (IsRefPtrType($interfaceName)) {
2883         push(@implContent, <<END);
2884     static_cast<${nativeType}*>(object)->deref();
2885 END
2886     }
2887
2888     push(@implContent, <<END);
2889 }
2890
2891 } // namespace WebCore
2892 END
2893
2894     my $conditionalString = GenerateConditionalString($dataNode);
2895     push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
2896     
2897     # We've already added the header for this file in implFixedHeader, so remove
2898     # it from implIncludes to ensure we don't #include it twice.
2899     delete $implIncludes{"${className}.h"};
2900 }
2901
2902 sub GenerateHeaderContentHeader
2903 {
2904     my $dataNode = shift;
2905     my $className = "V8" . $dataNode->name;
2906     my $conditionalString = GenerateConditionalString($dataNode);
2907
2908     my @headerContentHeader = split("\r", $headerTemplate);
2909
2910     push(@headerContentHeader, "\n#if ${conditionalString}\n") if $conditionalString;
2911     push(@headerContentHeader, "\n#ifndef ${className}" . "_h");
2912     push(@headerContentHeader, "\n#define ${className}" . "_h\n\n");
2913     return @headerContentHeader;
2914 }
2915
2916 sub GenerateImplementationContentHeader
2917 {
2918     my $dataNode = shift;
2919     my $className = "V8" . $dataNode->name;
2920     my $conditionalString = GenerateConditionalString($dataNode);
2921
2922     my @implContentHeader = split("\r", $headerTemplate);
2923
2924     push(@implContentHeader, "\n#include \"config.h\"\n");
2925     push(@implContentHeader, "#include \"${className}.h\"\n\n");
2926     push(@implContentHeader, "#if ${conditionalString}\n\n") if $conditionalString;
2927     return @implContentHeader;
2928 }
2929
2930 sub GenerateCallbackHeader
2931 {
2932     my $object = shift;
2933     my $dataNode = shift;
2934
2935     my $interfaceName = $dataNode->name;
2936     my $className = "V8$interfaceName";
2937
2938
2939     # - Add default header template
2940     push(@headerContent, GenerateHeaderContentHeader($dataNode));
2941
2942     my @unsortedIncludes = ();
2943     push(@unsortedIncludes, "#include \"ActiveDOMCallback.h\"");
2944     push(@unsortedIncludes, "#include \"$interfaceName.h\"");
2945     push(@unsortedIncludes, "#include \"WorldContextHandle.h\"");
2946     push(@unsortedIncludes, "#include <v8.h>");
2947     push(@unsortedIncludes, "#include <wtf/Forward.h>");
2948     push(@headerContent, join("\n", sort @unsortedIncludes));
2949     
2950     push(@headerContent, "\n\nnamespace WebCore {\n\n");
2951     push(@headerContent, "class ScriptExecutionContext;\n\n");
2952     push(@headerContent, "class $className : public $interfaceName, public ActiveDOMCallback {\n");
2953
2954     push(@headerContent, <<END);
2955 public:
2956     static PassRefPtr<${className}> create(v8::Local<v8::Value> value, ScriptExecutionContext* context)
2957     {
2958         ASSERT(value->IsObject());
2959         ASSERT(context);
2960         return adoptRef(new ${className}(value->ToObject(), context));
2961     }
2962
2963     virtual ~${className}();
2964
2965 END
2966
2967     # Functions
2968     my $numFunctions = @{$dataNode->functions};
2969     if ($numFunctions > 0) {
2970         push(@headerContent, "    // Functions\n");
2971         foreach my $function (@{$dataNode->functions}) {
2972             my @params = @{$function->parameters};
2973             if (!$function->signature->extendedAttributes->{"Custom"} &&
2974                 !(GetNativeType($function->signature->type) eq "bool")) {
2975                     push(@headerContent, "    COMPILE_ASSERT(false)");
2976             }
2977
2978             push(@headerContent, "    virtual " . GetNativeTypeForCallbacks($function->signature->type) . " " . $function->signature->name . "(");
2979
2980             my @args = ();
2981             foreach my $param (@params) {
2982                 push(@args, GetNativeTypeForCallbacks($param->type) . " " . $param->name);
2983             }
2984             push(@headerContent, join(", ", @args));
2985             push(@headerContent, ");\n");
2986         }
2987     }
2988
2989     push(@headerContent, <<END);
2990
2991 private:
2992     ${className}(v8::Local<v8::Object>, ScriptExecutionContext*);
2993
2994     v8::Persistent<v8::Object> m_callback;
2995     WorldContextHandle m_worldContext;
2996 };
2997
2998 END
2999
3000     push(@headerContent, "}\n\n");
3001     push(@headerContent, "#endif // $className" . "_h\n\n");
3002
3003     my $conditionalString = GenerateConditionalString($dataNode);
3004     push(@headerContent, "#endif // ${conditionalString}\n") if $conditionalString;
3005 }
3006
3007 sub GenerateCallbackImplementation
3008 {
3009     my $object = shift;
3010     my $dataNode = shift;
3011     my $interfaceName = $dataNode->name;
3012     my $className = "V8$interfaceName";
3013
3014     # - Add default header template
3015     push(@implFixedHeader, GenerateImplementationContentHeader($dataNode));
3016          
3017     AddToImplIncludes("ScriptExecutionContext.h");
3018     AddToImplIncludes("V8Binding.h");
3019     AddToImplIncludes("V8CustomVoidCallback.h");
3020     AddToImplIncludes("V8Proxy.h");
3021
3022     push(@implContent, "#include <wtf/Assertions.h>\n\n");
3023     push(@implContent, "namespace WebCore {\n\n");
3024     push(@implContent, <<END);
3025 ${className}::${className}(v8::Local<v8::Object> callback, ScriptExecutionContext* context)
3026     : ActiveDOMCallback(context)
3027     , m_callback(v8::Persistent<v8::Object>::New(callback))
3028     , m_worldContext(UseCurrentWorld)
3029 {
3030 }
3031
3032 ${className}::~${className}()
3033 {
3034     m_callback.Dispose();
3035 }
3036
3037 END
3038
3039     # Functions
3040     my $numFunctions = @{$dataNode->functions};
3041     if ($numFunctions > 0) {
3042         push(@implContent, "// Functions\n");
3043         foreach my $function (@{$dataNode->functions}) {
3044             my @params = @{$function->parameters};
3045             if ($function->signature->extendedAttributes->{"Custom"} ||
3046                 !(GetNativeTypeForCallbacks($function->signature->type) eq "bool")) {
3047                 next;
3048             }
3049
3050             AddIncludesForType($function->signature->type);
3051             push(@implContent, "\n" . GetNativeTypeForCallbacks($function->signature->type) . " ${className}::" . $function->signature->name . "(");
3052
3053             my @args = ();
3054             foreach my $param (@params) {
3055                 AddIncludesForType($param->type);
3056                 push(@args, GetNativeTypeForCallbacks($param->type) . " " . $param->name);
3057             }
3058             push(@implContent, join(", ", @args));
3059
3060             push(@implContent, ")\n");
3061             push(@implContent, "{\n");
3062             push(@implContent, "    if (!canInvokeCallback())\n");
3063             push(@implContent, "        return true;\n\n");
3064             push(@implContent, "    v8::HandleScope handleScope;\n\n");
3065             push(@implContent, "    v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);\n");
3066             push(@implContent, "    if (v8Context.IsEmpty())\n");
3067             push(@implContent, "        return true;\n\n");
3068             push(@implContent, "    v8::Context::Scope scope(v8Context);\n\n");
3069
3070             @args = ();
3071             foreach my $param (@params) {
3072                 my $paramName = $param->name;
3073                 push(@implContent, "    v8::Handle<v8::Value> ${paramName}Handle = " . NativeToJSValue($param, $paramName) . ";\n");
3074                 push(@implContent, "    if (${paramName}Handle.IsEmpty()) {\n");
3075                 push(@implContent, "        if (!isScriptControllerTerminating())\n");
3076                 push(@implContent, "            CRASH();\n");
3077                 push(@implContent, "        return true;\n");
3078                 push(@implContent, "    }\n");
3079                 push(@args, "        ${paramName}Handle");
3080             }
3081
3082             if (scalar(@args) > 0) {
3083                 push(@implContent, "\n    v8::Handle<v8::Value> argv[] = {\n");
3084                 push(@implContent, join(",\n", @args));
3085                 push(@implContent, "\n    };\n\n");
3086             } else {
3087                 push(@implContent, "\n    v8::Handle<v8::Value> *argv = 0;\n\n");
3088             }
3089             push(@implContent, "    bool callbackReturnValue = false;\n");
3090             push(@implContent, "    return !invokeCallback(m_callback, " . scalar(@params) . ", argv, callbackReturnValue, scriptExecutionContext());\n");
3091             push(@implContent, "}\n");
3092         }
3093     }
3094
3095     push(@implContent, "\n} // namespace WebCore\n\n");
3096
3097     my $conditionalString = GenerateConditionalString($dataNode);
3098     push(@implContent, "#endif // ${conditionalString}\n") if $conditionalString;
3099 }
3100
3101 sub GenerateToV8Converters
3102 {
3103     my $dataNode = shift;
3104     my $interfaceName = shift;
3105     my $className = shift;
3106     my $nativeType = shift;
3107
3108     my $domMapFunction = GetDomMapFunction($dataNode, $interfaceName);
3109     my $forceNewObjectInput = IsDOMNodeType($interfaceName) ? ", bool forceNewObject" : "";
3110     my $forceNewObjectCall = IsDOMNodeType($interfaceName) ? ", forceNewObject" : "";
3111
3112     push(@implContent, <<END);
3113
3114 v8::Handle<v8::Object> ${className}::wrapSlow(${nativeType}* impl)
3115 {
3116     v8::Handle<v8::Object> wrapper;
3117 END
3118
3119     my $proxyInit;
3120     if (IsNodeSubType($dataNode)) {
3121         $proxyInit = "V8Proxy::retrieve(impl->document()->frame())";
3122         # DocumentType nodes are the only nodes that may have a NULL document.
3123         if ($interfaceName eq "DocumentType") {
3124             $proxyInit = "impl->document() ? $proxyInit : 0";
3125         }
3126     } else {
3127         $proxyInit = "0";
3128     }
3129     push(@implContent, <<END);
3130     V8Proxy* proxy = $proxyInit;
3131 END
3132
3133     if (IsSubType($dataNode, "Document")) {
3134         push(@implContent, <<END);
3135     if (proxy && proxy->windowShell()->context().IsEmpty() && proxy->windowShell()->initContextIfNeeded()) {
3136         // initContextIfNeeded may have created a wrapper for the object, retry from the start.
3137         return ${className}::wrap(impl);
3138     }
3139 END
3140     }
3141
3142     # FIXME: We need a better way of recovering the correct prototype chain
3143     # for every sort of object. For now, we special-case cross-origin visible
3144     # objects (i.e., those with CheckSecurity).
3145     if (IsVisibleAcrossOrigins($dataNode)) {
3146         push(@implContent, <<END);
3147     if (impl->frame()) {
3148         proxy = V8Proxy::retrieve(impl->frame());
3149         if (proxy)
3150             proxy->windowShell()->initContextIfNeeded();
3151     }
3152 END
3153     }
3154
3155     if (IsNodeSubType($dataNode) || IsVisibleAcrossOrigins($dataNode)) {
3156         push(@implContent, <<END);
3157
3158     v8::Handle<v8::Context> context;
3159     if (proxy)
3160         context = proxy->context();
3161
3162     // Enter the node's context and create the wrapper in that context.
3163     if (!context.IsEmpty())
3164         context->Enter();
3165 END
3166     }
3167
3168     push(@implContent, <<END);
3169     wrapper = V8DOMWrapper::instantiateV8Object(proxy, &info, impl);
3170 END
3171     if (IsNodeSubType($dataNode) || IsVisibleAcrossOrigins($dataNode)) {
3172         push(@implContent, <<END);
3173     // Exit the node's context if it was entered.
3174     if (!context.IsEmpty())
3175         context->Exit();
3176 END
3177     }
3178
3179     push(@implContent, <<END);
3180     if (UNLIKELY(wrapper.IsEmpty()))
3181         return wrapper;
3182 END
3183     push(@implContent, "\n    impl->ref();\n") if IsRefPtrType($interfaceName);
3184
3185     push(@implContent, <<END);
3186     v8::Persistent<v8::Object> wrapperHandle = v8::Persistent<v8::Object>::New(wrapper);
3187
3188     if (!hasDependentLifetime)
3189         wrapperHandle.MarkIndependent();
3190 END
3191     if (IsNodeSubType($dataNode)) {
3192         push(@implContent, <<END);
3193     wrapperHandle.SetWrapperClassId(v8DOMSubtreeClassId);
3194 END
3195     }    
3196     push(@implContent, <<END);
3197     ${domMapFunction}.set(impl, wrapperHandle);
3198 END
3199
3200     push(@implContent, <<END);
3201     return wrapper;
3202 }
3203 END
3204 }
3205
3206 sub GetDomMapFunction
3207 {
3208     my $dataNode = shift;
3209     my $type = shift;
3210     return "getDOMSVGElementInstanceMap()" if $type eq "SVGElementInstance";
3211     return "getActiveDOMNodeMap()" if (IsNodeSubType($dataNode) && $dataNode->extendedAttributes->{"ActiveDOMObject"});
3212     return "getDOMNodeMap()" if (IsNodeSubType($dataNode));
3213     return "getActiveDOMObjectMap()" if $dataNode->extendedAttributes->{"ActiveDOMObject"};
3214     return "getDOMObjectMap()";
3215 }
3216
3217 sub GetNativeTypeForConversions
3218 {
3219     my $dataNode = shift;
3220     my $type = shift;
3221
3222     $type = $codeGenerator->GetSVGTypeNeedingTearOff($type) if $codeGenerator->IsSVGTypeNeedingTearOff($type); 
3223     return $type;
3224 }
3225
3226 sub GenerateFunctionCallString()
3227 {
3228     my $function = shift;
3229     my $numberOfParameters = shift;
3230     my $indent = shift;
3231     my $implClassName = shift;
3232     my %replacements = @_;
3233
3234     my $name = $function->signature->name;
3235     my $returnType = GetTypeFromSignature($function->signature);
3236     my $nativeReturnType = GetNativeType($returnType, 0);
3237     my $result = "";
3238
3239     my $isSVGTearOffType = ($codeGenerator->IsSVGTypeNeedingTearOff($returnType) and not $implClassName =~ /List$/);
3240     $nativeReturnType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($returnType) if $isSVGTearOffType;
3241
3242     if ($function->signature->extendedAttributes->{"ImplementedAs"}) {
3243         $name = $function->signature->extendedAttributes->{"ImplementedAs"};
3244     }
3245
3246     my $index = 0;
3247     my $hasScriptState = 0;
3248
3249     my @arguments;
3250     my $functionName;
3251     my $implementedBy = $function->signature->extendedAttributes->{"ImplementedBy"};
3252     if ($implementedBy) {
3253         AddToImplIncludes("${implementedBy}.h");
3254         unshift(@arguments, "imp") if !$function->isStatic;
3255         $functionName = "${implementedBy}::${name}";
3256     } elsif ($function->isStatic) {
3257         $functionName = "${implClassName}::${name}";
3258     } else {
3259         $functionName = "imp->${name}";
3260     }
3261
3262     my $callWith = $function->signature->extendedAttributes->{"CallWith"};
3263     my @callWithOutput = ();
3264     my @callWithArgs = GenerateCallWith($callWith, \@callWithOutput, $indent, 0, 1, $function);
3265     $result .= join("", @callWithOutput);
3266     push(@arguments, @callWithArgs);
3267     $index += @callWithArgs;
3268     $numberOfParameters += @callWithArgs;
3269
3270     foreach my $parameter (@{$function->parameters}) {
3271         if ($index eq $numberOfParameters) {
3272             last;
3273         }
3274         my $paramName = $parameter->name;
3275         my $paramType = $parameter->type;
3276
3277         if ($replacements{$paramName}) {
3278             push @arguments, $replacements{$paramName};
3279         } elsif ($parameter->type eq "IDBKey" || $parameter->type eq "NodeFilter" || $parameter->type eq "XPathNSResolver") {
3280             push @arguments, "$paramName.get()";
3281         } elsif ($codeGenerator->IsSVGTypeNeedingTearOff($parameter->type) and not $implClassName =~ /List$/) {
3282             push @arguments, "$paramName->propertyReference()";
3283             $result .= $indent . "if (!$paramName) {\n";
3284             $result .= $indent . "    V8Proxy::setDOMException(WebCore::TYPE_MISMATCH_ERR);\n";
3285             $result .= $indent . "    return v8::Handle<v8::Value>();\n";
3286             $result .= $indent . "}\n";
3287         } elsif ($parameter->type eq "SVGMatrix" and $implClassName eq "SVGTransformList") {
3288             push @arguments, "$paramName.get()";
3289         } else {
3290             push @arguments, $paramName;
3291         }
3292         $index++;
3293     }
3294
3295     if (@{$function->raisesExceptions}) {
3296         push @arguments, "ec";
3297     }
3298
3299     my $functionString = "$functionName(" . join(", ", @arguments) . ")";
3300
3301     my $return = "result";
3302     my $returnIsRef = IsRefPtrType($returnType);
3303
3304     if ($returnType eq "void") {
3305         $result .= $indent . "$functionString;\n";
3306     } elsif ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptState") or @{$function->raisesExceptions}) {
3307         $result .= $indent . $nativeReturnType . " result = $functionString;\n";
3308     } else {
3309         # Can inline the function call into the return statement to avoid overhead of using a Ref<> temporary
3310         $return = $functionString;
3311         $returnIsRef = 0;
3312
3313         if ($implClassName eq "SVGTransformList" and IsRefPtrType($returnType)) {
3314             $return = "WTF::getPtr(" . $return . ")";
3315         }
3316     }
3317
3318     if (@{$function->raisesExceptions}) {
3319         $result .= $indent . "if (UNLIKELY(ec))\n";
3320         $result .= $indent . "    goto fail;\n";
3321     }
3322
3323     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptState")) {
3324         $result .= $indent . "if (state.hadException())\n";
3325         $result .= $indent . "    return throwError(state.exception());\n"
3326     }
3327
3328     if ($isSVGTearOffType) {
3329         AddToImplIncludes("V8$returnType.h");
3330         AddToImplIncludes("SVGPropertyTearOff.h");
3331         my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($returnType);
3332         $result .= $indent . "return toV8(WTF::getPtr(${svgNativeType}::create($return)));\n";
3333         return $result;
3334     }
3335
3336     # If the implementing class is a POD type, commit changes
3337     if ($codeGenerator->IsSVGTypeNeedingTearOff($implClassName) and not $implClassName =~ /List$/) {
3338         $result .= $indent . "wrapper->commitChange();\n";
3339     }
3340
3341     $return .= ".release()" if ($returnIsRef);
3342     $result .= $indent . ReturnNativeToJSValue($function->signature, $return, $indent) . ";\n";
3343
3344     return $result;
3345 }
3346
3347
3348 sub GetTypeFromSignature
3349 {
3350     my $signature = shift;
3351
3352     return $codeGenerator->StripModule($signature->type);
3353 }
3354
3355
3356 sub GetNativeTypeFromSignature
3357 {
3358     my $signature = shift;
3359     my $parameterIndex = shift;
3360
3361     my $type = GetTypeFromSignature($signature);
3362
3363     if ($type eq "unsigned long" and $signature->extendedAttributes->{"IsIndex"}) {
3364         # Special-case index arguments because we need to check that they aren't < 0.
3365         return "int";
3366     }
3367
3368     $type = GetNativeType($type, $parameterIndex >= 0 ? 1 : 0);
3369
3370     if ($parameterIndex >= 0 && $type eq "V8Parameter") {
3371         # FIXME: This implements [TreatNullAs=NullString] and [TreatUndefinedAs=NullString],
3372         # but the Web IDL spec requires [TreatNullAs=EmptyString] and [TreatUndefinedAs=EmptyString].
3373         my $mode = "";
3374         if (($signature->extendedAttributes->{"TreatNullAs"} and $signature->extendedAttributes->{"TreatNullAs"} eq "NullString") and ($signature->extendedAttributes->{"TreatUndefinedAs"} and $signature->extendedAttributes->{"TreatUndefinedAs"} eq "NullString")) {
3375             $mode = "WithUndefinedOrNullCheck";
3376         } elsif (($signature->extendedAttributes->{"TreatNullAs"} and $signature->extendedAttributes->{"TreatNullAs"} eq "NullString") or $signature->extendedAttributes->{"Reflect"}) {
3377             $mode = "WithNullCheck";
3378         }
3379         # FIXME: Add the case for 'elsif ($signature->extendedAttributes->{"TreatUndefinedAs"} and $signature->extendedAttributes->{"TreatUndefinedAs"} eq "NullString"))'.
3380         $type .= "<$mode>";
3381     }
3382
3383     return $type;
3384 }
3385
3386 sub IsRefPtrType
3387 {
3388     my $type = shift;
3389
3390     return 0 if $type eq "boolean";
3391     return 0 if $type eq "float";
3392     return 0 if $type eq "int";
3393     return 0 if $type eq "Date";
3394     return 0 if $type eq "DOMString";
3395     return 0 if $type eq "double";
3396     return 0 if $type eq "short";
3397     return 0 if $type eq "long";
3398     return 0 if $type eq "unsigned";
3399     return 0 if $type eq "unsigned long";
3400     return 0 if $type eq "unsigned short";
3401     return 0 if $type eq "float[]";
3402     return 0 if $type eq "double[]";
3403
3404     return 1;
3405 }
3406
3407 sub GetNativeType
3408 {
3409     my $type = shift;
3410     my $isParameter = shift;
3411
3412     my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($type);
3413     if ($svgNativeType) {
3414         if ($svgNativeType =~ /List$/) {
3415             return "${svgNativeType}*";
3416         } else {
3417             return "RefPtr<${svgNativeType} >";
3418         }
3419     }
3420
3421     if ($type eq "float" or $type eq "double") {
3422         return $type;
3423     }
3424
3425     return "V8Parameter" if ($type eq "DOMString" or $type eq "DOMUserData") and $isParameter;
3426     return "int" if $type eq "int";
3427     return "int" if $type eq "short" or $type eq "unsigned short";
3428     return "unsigned" if $type eq "unsigned long";
3429     return "int" if $type eq "long";
3430     return "long long" if $type eq "long long";
3431     return "unsigned long long" if $type eq "unsigned long long";
3432     return "bool" if $type eq "boolean";
3433     return "String" if $type eq "DOMString";
3434     return "Range::CompareHow" if $type eq "CompareHow";
3435     return "DOMTimeStamp" if $type eq "DOMTimeStamp";
3436     return "unsigned" if $type eq "unsigned int";
3437     return "Node*" if $type eq "EventTarget" and $isParameter;
3438     return "double" if $type eq "Date";
3439     return "ScriptValue" if $type eq "DOMObject";
3440     return "Dictionary" if $type eq "Dictionary";
3441
3442     return "String" if $type eq "DOMUserData";  # FIXME: Temporary hack?
3443
3444     # temporary hack
3445     return "RefPtr<NodeFilter>" if $type eq "NodeFilter";
3446
3447     return "RefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
3448
3449     return "RefPtr<IDBKey>" if $type eq "IDBKey";
3450
3451     # necessary as resolvers could be constructed on fly.
3452     return "RefPtr<XPathNSResolver>" if $type eq "XPathNSResolver";
3453
3454     return "RefPtr<${type}>" if IsRefPtrType($type) and not $isParameter;
3455
3456     return "RefPtr<MediaQueryListListener>" if $type eq "MediaQueryListListener";
3457
3458     # FIXME: Support T[], T[]?, sequence<T> generically
3459     return "Vector<float>" if $type eq "float[]";
3460     return "Vector<double>" if $type eq "double[]";
3461     return "RefPtr<DOMStringList>" if $type eq "DOMStringList";
3462     return "RefPtr<DOMStringList>" if $type eq "DOMString[]";
3463
3464     # Default, assume native type is a pointer with same type name as idl type
3465     return "${type}*";
3466 }
3467
3468 sub GetNativeTypeForCallbacks
3469 {
3470     my $type = shift;
3471     return "const String&" if $type eq "DOMString";
3472     return "SerializedScriptValue*" if $type eq "SerializedScriptValue";
3473
3474     # Callbacks use raw pointers, so pass isParameter = 1
3475     return GetNativeType($type, 1);
3476 }
3477
3478 sub TranslateParameter
3479 {
3480     my $signature = shift;
3481
3482     # The IDL uses some pseudo-types which don't really exist.
3483     if ($signature->type eq "TimeoutHandler") {
3484       $signature->type("DOMString");
3485     }
3486 }
3487
3488 sub TypeCanFailConversion
3489 {
3490     my $signature = shift;
3491
3492     my $type = GetTypeFromSignature($signature);
3493
3494     AddToImplIncludes("ExceptionCode.h") if $type eq "Attr";
3495     return 1 if $type eq "Attr";
3496     return 1 if $type eq "VoidCallback";
3497     return 0;
3498 }
3499
3500 sub JSValueToNative
3501 {
3502     my $signature = shift;
3503     my $value = shift;
3504
3505     my $type = GetTypeFromSignature($signature);
3506
3507     return "$value" if $type eq "JSObject";
3508     return "$value->BooleanValue()" if $type eq "boolean";
3509     return "static_cast<$type>($value->NumberValue())" if $type eq "float" or $type eq "double";
3510
3511     return "toInt32($value)" if $type eq "long" or $type eq "short";
3512     return "toUInt32($value)" if $type eq "unsigned long" or $type eq "unsigned short";
3513     return "toInt64($value)" if $type eq "unsigned long long" or $type eq "long long";
3514     return "static_cast<Range::CompareHow>($value->Int32Value())" if $type eq "CompareHow";
3515     return "toWebCoreDate($value)" if $type eq "Date";
3516     return "v8ValueToWebCoreDOMStringList($value)" if $type eq "DOMStringList";
3517     # FIXME: Add proper support for T[], T[]? and sequence<T>.
3518     return "v8ValueToWebCoreDOMStringList($value)" if $type eq "DOMString[]";
3519     if ($type eq "float[]") {
3520         AddToImplIncludes("wtf/Vector.h");
3521         return "v8NumberArrayToVector<float>($value)";
3522     }
3523     if ($type eq "double[]") {
3524         AddToImplIncludes("wtf/Vector.h");
3525         return "v8NumberArrayToVector<double>($value)";
3526     }
3527
3528     if ($type eq "DOMString" or $type eq "DOMUserData") {
3529         return $value;
3530     }
3531
3532     if ($type eq "SerializedScriptValue") {
3533         AddToImplIncludes("SerializedScriptValue.h");
3534         return "SerializedScriptValue::create($value)";
3535     }
3536
3537     if ($type eq "IDBKey") {
3538         AddToImplIncludes("IDBBindingUtilities.h");
3539         AddToImplIncludes("IDBKey.h");
3540         return "createIDBKeyFromValue($value)";
3541     }
3542
3543     if ($type eq "Dictionary") {
3544         AddToImplIncludes("Dictionary.h");
3545         return $value;
3546     }
3547
3548     if ($type eq "DOMObject") {
3549         AddToImplIncludes("ScriptValue.h");
3550         return "ScriptValue($value)";
3551     }
3552
3553     if ($type eq "NodeFilter") {
3554         return "V8DOMWrapper::wrapNativeNodeFilter($value)";
3555     }
3556
3557     if ($type eq "MediaQueryListListener") {
3558         AddToImplIncludes("MediaQueryListListener.h");
3559         return "MediaQueryListListener::create(" . $value . ")";
3560     }
3561
3562     # Default, assume autogenerated type conversion routines
3563     if ($type eq "EventTarget") {
3564         AddToImplIncludes("V8Node.h");
3565
3566         # EventTarget is not in DOM hierarchy, but all Nodes are EventTarget.
3567         return "V8Node::HasInstance($value) ? V8Node::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
3568     }
3569
3570     if ($type eq "XPathNSResolver") {
3571         return "V8DOMWrapper::getXPathNSResolver($value)";
3572     }
3573
3574     if ($codeGenerator->GetArrayType($type)) {
3575         return "toNativeArray($value)";
3576     }
3577
3578     AddIncludesForType($type);
3579
3580     if (IsDOMNodeType($type)) {
3581         AddToImplIncludes("V8${type}.h");
3582
3583         # Perform type checks on the parameter, if it is expected Node type,
3584         # return NULL.
3585         return "V8${type}::HasInstance($value) ? V8${type}::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
3586     } else {
3587         AddToImplIncludes("V8$type.h");
3588
3589         # Perform type checks on the parameter, if it is expected Node type,
3590         # return NULL.
3591         return "V8${type}::HasInstance($value) ? V8${type}::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
3592     }
3593 }
3594
3595 sub GetV8HeaderName
3596 {
3597     my $type = shift;
3598     return "V8Event.h" if $type eq "DOMTimeStamp";
3599     return "EventListener.h" if $type eq "EventListener";
3600     return "EventTarget.h" if $type eq "EventTarget";
3601     return "SerializedScriptValue.h" if $type eq "SerializedScriptValue";
3602     return "ScriptValue.h" if $type eq "DOMObject";
3603     return "V8DOMStringList.h" if $type eq "DOMString[]";
3604     return "V8${type}.h";
3605 }
3606
3607 sub CreateCustomSignature
3608 {
3609     my $function = shift;
3610     my $count = @{$function->parameters};
3611     my $name = $function->signature->name;
3612     my $result = "    const int ${name}Argc = ${count};\n" .
3613       "    v8::Handle<v8::FunctionTemplate> ${name}Argv[${name}Argc] = { ";
3614     my $first = 1;
3615     foreach my $parameter (@{$function->parameters}) {
3616         if ($first) { $first = 0; }
3617         else { $result .= ", "; }
3618         if (IsWrapperType($parameter->type)) {
3619             if ($parameter->type eq "XPathNSResolver") {
3620                 # Special case for XPathNSResolver.  All other browsers accepts a callable,
3621                 # so, even though it's against IDL, accept objects here.
3622                 $result .= "v8::Handle<v8::FunctionTemplate>()";
3623             } else {
3624                 my $type = $parameter->type;
3625                 my $header = GetV8HeaderName($type);
3626                 AddToImplIncludes($header);
3627                 $result .= "V8${type}::GetRawTemplate()";
3628             }
3629         } else {
3630             $result .= "v8::Handle<v8::FunctionTemplate>()";
3631         }
3632     }
3633     $result .= " };\n";
3634     $result .= "    v8::Handle<v8::Signature> ${name}Signature = v8::Signature::New(desc, ${name}Argc, ${name}Argv);\n";
3635     return $result;
3636 }
3637
3638
3639 sub RequiresCustomSignature
3640 {
3641     my $function = shift;
3642     # No signature needed for Custom function
3643     if ($function->signature->extendedAttributes->{"Custom"} ||
3644         $function->signature->extendedAttributes->{"V8Custom"}) {
3645         return 0;
3646     }
3647     # No signature needed for overloaded function
3648     if (@{$function->{overloads}} > 1) {
3649         return 0;
3650     }
3651     # Type checking is performed in the generated code
3652     if ($function->signature->extendedAttributes->{"StrictTypeChecking"}) {
3653       return 0;
3654     }
3655     foreach my $parameter (@{$function->parameters}) {
3656         my $optional = $parameter->extendedAttributes->{"Optional"};
3657         if (($optional && $optional ne "DefaultIsUndefined" && $optional ne "DefaultIsNullString") || $parameter->extendedAttributes->{"Callback"}) {
3658             return 0;
3659         }
3660     }
3661
3662     foreach my $parameter (@{$function->parameters}) {
3663         if (IsWrapperType($parameter->type)) {
3664             return 1;
3665         }
3666     }
3667     return 0;
3668 }
3669
3670
3671 # FIXME: Sort this array.
3672 my %non_wrapper_types = (
3673     'float' => 1,
3674     'double' => 1,
3675     'int' => 1,
3676     'unsigned int' => 1,
3677     'short' => 1,
3678     'unsigned short' => 1,
3679     'long' => 1,
3680     'unsigned long' => 1,
3681     'boolean' => 1,
3682     'long long' => 1,
3683     'unsigned long long' => 1,
3684     'float[]' => 1,
3685     'double[]' => 1,
3686     'DOMString' => 1,
3687     'CompareHow' => 1,
3688     'SerializedScriptValue' => 1,
3689     'DOMTimeStamp' => 1,
3690     'JSObject' => 1,
3691     'DOMObject' => 1,
3692     'EventTarget' => 1,
3693     'NodeFilter' => 1,
3694     'EventListener' => 1,
3695     'IDBKey' => 1,
3696     'Dictionary' => 1,
3697     'Date' => 1,
3698     'MediaQueryListListener' => 1
3699 );
3700
3701
3702 sub IsWrapperType
3703 {
3704     my $type = $codeGenerator->StripModule(shift);
3705     return !($non_wrapper_types{$type});
3706 }
3707
3708 sub IsArrayType
3709 {
3710     my $type = $codeGenerator->StripModule(shift);
3711     # FIXME: Add proper support for T[], T[]?, sequence<T>.
3712     return $type =~ m/\[\]$/;
3713 }
3714
3715 sub IsDOMNodeType
3716 {
3717     my $type = shift;
3718
3719     return 1 if $type eq 'Attr';
3720     return 1 if $type eq 'CDATASection';
3721     return 1 if $type eq 'Comment';
3722     return 1 if $type eq 'Document';
3723     return 1 if $type eq 'DocumentFragment';
3724     return 1 if $type eq 'DocumentType';
3725     return 1 if $type eq 'Element';
3726     return 1 if $type eq 'EntityReference';
3727     return 1 if $type eq 'HTMLCanvasElement';
3728     retu