WebGL support.

Source/WebCore/bindings/dart/gyp/scripts/CodeGeneratorDart.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 #
@@ skipping 90 matching lines @@
 
     # Commit changes!
     $object->WriteData();
 }
 
 sub GenerateModule
 {
     my ($object, $dataNode) = @_;
 }
 
+my %overrideConstructorParameters = (
+    "Float32Array" => 3,
+    "Float64Array" => 3,
+    "Int8Array" => 3,
+    "Int16Array" => 3,
+    "Int32Array" => 3,
+    "Uint8Array" => 3,
+    "Uint16Array" => 3,
+    "Uint32Array" => 3,
+);
+
+sub ConstructorParameterCount
+{
+    my ($dataNode) = @_;
+    return $overrideConstructorParameters{$dataNode->name} if (exists $overrideConstructorParameters{$dataNode->name});
+    return $dataNode->extendedAttributes->{ConstructorParameters} if (exists $dataNode->extendedAttributes->{ConstructorParameters});
+    return 0;
+}
+
 sub GenerateInterface
 {
     my ($object, $dataNode, $defines) = @_;
 
     # Add parent classes (for multiple-inheritance) fields as needed.
     @allParents = ();
     $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@allParents, 0);
     # Prepare internal structures.
     $codeGenerator->LinkOverloadedFunctions($dataNode);
 
@@ skipping 84 matching lines @@
     # FIXME: useCapture was marked as optional upstream, however native
     # implementation still requires all three parameters. JavaScript bindings
     # have custom generation for addEventListener and removeEventListener.
     return 0 if $function->signature->name eq "addEventListener" || $function->signature->name eq "removeEventListener";
 
     foreach my $parameter (@{$function->parameters}) {
         return 1 if IsParameterOptionalInWebKit($parameter);
     }
 }
 
+sub CanBeConstructed
+{
+    my ($dataNode) = @_;
+
+    return 
+        $dataNode->extendedAttributes->{CanBeConstructed} || HasCustomConstructor($dataNode);
+}
+
 sub HasCustomConstructor
 {
     my ($dataNode) = @_;
 
-    # FIXME: switch to using CanBeConstructed attribute.
-    return 1 if $dataNode->name eq "FileReader";
-    return 1 if $dataNode->name eq "XMLHttpRequest";
-    return 1 if $dataNode->name eq "WebKitCSSMatrix";
-    return 1 if $dataNode->name eq "WebKitPoint";
-
-    return 0;
+    return $dataNode->extendedAttributes->{CustomConstructor} && not ($dataNode->name =~ "Event");
 }
 
 sub IsParameterOptionalInWebKit
 {
     my ($parameter) = @_;
 
     # Optional callbacks are not optional parameters in native implementations, they always have a default value (0).
     my $optional = $parameter->extendedAttributes->{Optional};
     return $optional && $optional ne "CallWithDefaultValue" && !$parameter->extendedAttributes->{Callback};
 }
@@ skipping 134 matching lines @@
 
 sub IDLTypeToW3C
 {
     my ($idlType,) = @_;
     return $idlTypeToW3C{$idlType} if exists $idlTypeToW3C{$idlType};
     return $idlType;
 }
 
 my %idlTypeToDart = (
   "any" => "Object",
+  "any[]" => "List",
   "boolean" => "bool",
   "custom" => "Object",
   "object" => "Object",
   "Array" => "List",
   "DOMObject" => "Object",
   "DOMString" => "String",
   "DOMString[]" => "DOMStringList",
   "DOMTimeStamp" => "int",
   "ObjectArray" => "List",
   "SerializedScriptValue" => "Object",
@@ skipping 953 matching lines @@
   "SVGFitToViewBox" => 1,
   "SVGLangSpace" => 1,
   "SVGLocatable" => 1,
   "SVGStylable" => 1,
   "SVGTests" => 1,
   "SVGTransformable" => 1,
   "SVGViewSpec" => 1,
   "SVGZoomAndPan" => 1,
 );
 
-sub ListLike
+sub ListLikeWithBase
 {
-    my ($elementType, $needsAuxiliaryAccessors) = @_;
+    my ($elementType, $baseClass, $needsAuxiliaryAccessors) = @_;
 
     my @auxiliaryMethods = ();
     if ($needsAuxiliaryAccessors) {
         push(@auxiliaryMethods, ["$elementType operator [] (int index)", "numericIndexGetter", 2]);
         push(@auxiliaryMethods, ["void operator []= (int index, $elementType value)", "numericIndexSetter", 3]);
     }
 
     return IDLTypeInfoStruct->new(
         additionalInterfaces => ["List<$elementType>"],
-        superClass => "ListBase<$elementType>",
+        superClass => "$baseClass",
         auxilaryMethods => \@auxiliaryMethods
     );
 }
 
+sub ListLike
+{
+    my ($elementType, $needsAuxiliaryAccessors) = @_;
+
+    return ListLikeWithBase($elementType, "ListBase<$elementType>", $needsAuxiliaryAccessors);
+}
+
+sub ArrayBufferLike
+{
+    my ($elementType, $needsAuxiliaryAccessors) = @_;
+
+    return ListLikeWithBase($elementType, "ArrayBufferViewImplementation", $needsAuxiliaryAccessors);
+}
+
 sub MapLike
 {
     # FIXME: most probably we need to deduce more types using hints like
     # HasNameGetter, CustomDeleteProperty, CustomGetPropertyNames, DelegatingPutFunction
     # attributes.
     # FIXME: technically at least DOMStringMap.setItem and DOMStringMap.item could be automatically
     # generated and then used from [] and []=.  I don't do it for now not to mess up with IDLs too
     # much.
     # FIXME: support removal of elements if allowed (it is at least for DOMStringMap.)
     my ($interfaceName, $keyType, $elementType) = @_;
     return IDLTypeInfoStruct->new(
         additionalInterfaces => ["Map<$keyType, $elementType>"],
         superClass => "MapBase<$keyType, $elementType>",
         auxilaryMethods => [
             ["Collection<$keyType> getKeys()", "getKeys", 1],
             ["$elementType operator [] ($keyType k)", "item", 2],
             ["operator []= ($keyType k, $elementType v)", "setItem", 3],
             ["$elementType remove($keyType k)", "deleteItem", 2],
         ],
     );
 }
 
 my %idlTypeInfoOverrides = (
   "CanvasPixelArray" => ListLike("int", 1),
   "DOMStringMap" => MapLike("DOMStringMap", "String", "String"),
   "HTMLCollection" => ListLike("Node"),
   "NodeList" => ListLike("Node"),
   "StyleSheetList" => ListLike("StyleSheet"),
+  "ArrayBufferView" => ListLikeWithBase("num", "ListBase<num>"),
+  "Float32Array" => ArrayBufferLike("double", 1),
+  "Float64Array" => ArrayBufferLike("double", 1),
+  "Int8Array" => ArrayBufferLike("int", 1),
+  "Int16Array" => ArrayBufferLike("int", 1),
+  "Int32Array" => ArrayBufferLike("int", 1),
+  "Uint8Array" => ArrayBufferLike("int", 1),
+  "Uint16Array" => ArrayBufferLike("int", 1),
+  "Uint32Array" => ArrayBufferLike("int", 1),
 );
 
 # FIXME: turn into the single IDL type info registry.
 sub IDLTypeInfo
 {
     my ($dataNode,) = @_;
     my $override = $idlTypeInfoOverrides{$dataNode->name};
     return $override if $override;
 
     my $parentInterface = ParentInterface($dataNode);
@@ skipping 21 matching lines @@
 
     push(@implementedInterfaces, @{IDLTypeInfo($dataNode)->additionalInterfaces});
     push(@implementedInterfaces, @allParents);
 
     if (@implementedInterfaces) {
         $extendsClause = " extends " . join(", ", @implementedInterfaces);
     }
 
     # Build default clause if any.
     my $defaultClause = "";
-    if (HasCustomConstructor($dataNode)) {
+    if (CanBeConstructed($dataNode)) {
         $defaultClause = " default ${w3cInterfaceName}Implementation";
         push(@customCallbackDeclarations, GenerateCustomCallbackDeclaration("constructorCallback"));
     }
 
     push(@dartInterfaceContent, "\ninterface ${w3cInterfaceName}${extendsClause}${defaultClause} {\n");
     push(@dartInterfaceContent, "\n  // Constants.\n");
     foreach my $constant (@{$dataNode->constants}) {
         my $name = $constant->name;
         my $value = $constant->value;
 
@@ skipping 30 matching lines @@
 
     foreach my $auxilaryMethod (@{IDLTypeInfo($dataNode)->auxilaryMethods}) {
         my $dartDeclaration = $auxilaryMethod->[0];
         my $descriptor = CreateFunctionNativeDescriptor($interfaceName, $auxilaryMethod->[1], $auxilaryMethod->[2]);
         my $nativeId = $descriptor->nativeId;
         push(@dartImplContent, "  $dartDeclaration native \"$nativeId\";\n");
         push(@customCallbackDeclarations, GenerateCustomCallbackDeclaration($descriptor->cppCallbackName));
     }
 
     if (HasCustomConstructor($dataNode)) {
-        my $parameterCount = $dataNode->extendedAttributes->{"ConstructorParameters"} || 0;
+        my $parameterCount = ConstructorParameterCount($dataNode);
         my $descriptor = CreateFunctionNativeDescriptor($interfaceName, "constructor", 1 + $parameterCount);
         my $nativeId = $descriptor->nativeId;
         my $parameters = DartAnonymousNamedOptionalParameters($parameterCount);
         my $arguments = DartAnonymousArguments($parameterCount);
         push(@dartInterfaceContent, "  $w3cInterfaceName($parameters);\n");
         push(@dartImplContent, <<END);
   $implementationClassName($parameters) {
     this._bind($arguments);
   }
 END
@@ skipping 186 matching lines @@
 
     if (defined($DART_IMPL)) {
       # Write content of Dart file.
       print $DART_IMPL @dartImplContent;
       close($DART_IMPL);
       undef($DART_IMPL);
 
       @dartImplContent = ();
     }
 }