Switch to using dartdomgenerator.py for Dart interface and implementation generation.

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 84 matching lines @@
     bless($reference, $object);
     return $reference;
 }
 
 sub GenerateModule
 {
     my ($object, $dataNode) = @_;
 }
 
 my %overrideConstructorParameters = (
-    "Float32Array" => 3,
-    "Float64Array" => 3,
-    "Int8Array" => 3,
-    "Int16Array" => 3,
-    "Int32Array" => 3,
-    "Uint8Array" => 3,
-    "Uint16Array" => 3,
-    "Uint32Array" => 3,
+    "Float32Array" => 1,
+    "Float64Array" => 1,
+    "Int8Array" => 1,
+    "Int16Array" => 1,
+    "Int32Array" => 1,
+    "Uint8Array" => 1,
+    "Uint16Array" => 1,
+    "Uint32Array" => 1,
 );
 
 sub ConstructorParameterCount
 {
     my ($dataNode) = @_;
     return $overrideConstructorParameters{$dataNode->name} if (exists $overrideConstructorParameters{$dataNode->name});
     return $dataNode->extendedAttributes->{ConstructorParameters} if (exists $dataNode->extendedAttributes->{ConstructorParameters});
     return 0;
 }
 
@@ skipping 15 matching lines @@
     } else {
         $object->GenerateSource($dataNode);
         $object->GenerateHeader($dataNode);
     }
 
     my $name = $dataNode->name;
 
     # Open files for writing
     my $headerFileName = "$outputHeadersDir/Dart${name}.h";
     my $implFileName = "$outputDir/Dart${name}.cpp";
-    my $dartInterfaceFileName = "$outputHeadersDir/${name}.dart";
-    my $dartImplFileName = "$outputHeadersDir/${name}Implementation.dart";
 
     open($IMPL, ">$implFileName") || die "Couldn't open file $implFileName";
     open($HEADER, ">$headerFileName") || die "Couldn't open file $headerFileName";
-    open($DART_INTERFACE, ">$dartInterfaceFileName") || die "Couldn't open file $dartInterfaceFileName";
-    open($DART_IMPL, ">$dartImplFileName") || die "Couldn't open file $dartImplFileName";
 
     $object->WriteData($dataNode);
 }
 
 # If the node has a [Conditional=XXX] attribute, returns an "ENABLE(XXX)" string for use in an #if.
 # FIXME: common with CodeGeneratorV8
 sub GenerateConditionalStringForAttributes
 {
     my ($attributes,) = @_;
 
@@ skipping 44 matching lines @@
         my $parameterCount = @{$overload->parameters};
         $maxParameterCount = $maxParameterCount > $parameterCount ? $maxParameterCount : $parameterCount;
     }
     return $maxParameterCount;
 }
 
 sub HasOptionalParameters
 {
     my ($function) = @_;
 
-    # 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} ||
@@ skipping 208 matching lines @@
 my %nonWrapperTypes = (
     "CompareHow" => 1,
     "EventListener" => 1,
     "EventTarget" => 1,
     "MediaQueryListListener" => 1,
     "OptionsObject" => 1,
     "VoidCallback" => 1,
     "WebKitFlags" => 1,
 );
 
+sub DartInterfaceName
+{
+    my ($interfaceName,) = @_;
+    return "DOMException" if $interfaceName eq "DOMCoreException";
+    return $interfaceName;
+}
+
 sub IsIDLTypeWithDartBindings
 {
     my ($idlType,) = @_;
 
     return 0 if exists $idlTypeToDart{$idlType};
     return 0 if exists $primitiveDartTypes{$idlType};
     return 0 if !IsRefPtrType(IDLTypeToDart($idlType));
     return 0 if exists $nonWrapperTypes{$idlType};
 
     return 1;
@@ skipping 280 matching lines @@
         push(@defineInvocationParameters, <<END);
         const $parameterAdapterType $name($adapterParameters);
         if (!$name.conversionSuccessful()) {
             exception = $name.exception();
             goto fail;
         }
 END
     }
     @invocationParameters = (@invocationParameters, map { $_->name; } @{$parameters});
 
+    if ($functionName eq "addEventListener" or $functionName eq "removeEventListener") {
+        # addEventListener's and removeEventListener's last argument is marked
+        # as optional in idl, but is not optional in c++ implementation.
+        push(@invocationParameters, "false") if (@invocationParameters == 2);
+    }
+
     if ($attributes->{CustomArgumentHandling}) {
         $implIncludes{"ScriptArguments.h"} = 1;
         $implIncludes{"ScriptCallStack.h"} = 1;
         $implIncludes{"V8Proxy.h"} = 1;
         $implIncludes{"v8.h"} = 1;
         my $customArgument = $parameterCount + 1;
         push(@defineInvocationParameters, <<END);
         v8::HandleScope handleScope;
         v8::Context::Scope scope(V8Proxy::mainWorldContext(DartUtilities::domWindowForCurrentIsolate()->frame()));
 
@@ skipping 196 matching lines @@
 }
 
 END
 }
 
 sub GenerateDartImplementationClassname
 {
     my ($interfaceName,) = @_;
 
     my $className = ClassName($interfaceName);
+    my $dartInterfaceName = DartInterfaceName($interfaceName);
 
     push(@implContent, <<END);
 
-const char* const ${className}::dartImplementationClassName = "${interfaceName}Implementation";
+const char* const ${className}::dartImplementationClassName = "${dartInterfaceName}Implementation";
 END
 }
 
 sub GenerateImplementationPrologue
 {
     my ($dataNode) = @_;
 
     my $interfaceName = $dataNode->name;
     my $className = ClassName($interfaceName);
     my $internalNamespaceName = "Dart${interfaceName}Internal";
@@ skipping 257 matching lines @@
 sub DartAnonymousNamedOptionalParameters
 {
     my ($parameterCount) = @_;
     return "" unless $parameterCount;
     return "[" . DartAnonymousArguments($parameterCount) . "]";
 }
 
 sub CreateFunctionNativeDescriptor
 {
     my ($interfaceName, $functionName, $argumentCount) = @_;
+
+    my $dartInterfaceName = DartInterfaceName($interfaceName);
     my $descriptor = NativeBindingDescriptor->new(
         cppCallbackName => "${functionName}Callback",
-        nativeId => "${interfaceName}_${functionName}_Callback",
+        nativeId => "${dartInterfaceName}_${functionName}_Callback",
         argumentCount => $argumentCount);
     push(@dartNatives, $descriptor);
     return $descriptor;
 }
 
 sub CreateGetterNativeDescriptor
 {
     my ($interfaceName, $attributeName) = @_;
+    my $dartInterfaceName = DartInterfaceName($interfaceName);
     my $descriptor = NativeBindingDescriptor->new(
         cppCallbackName => "${attributeName}Getter",
-        nativeId => "${interfaceName}_${attributeName}_Getter",
+        nativeId => "${dartInterfaceName}_${attributeName}_Getter",
         argumentCount => 1);
     push(@dartNatives, $descriptor);
     return $descriptor;
 }
 
 sub CreateSetterNativeDescriptor
 {
     my ($interfaceName, $attributeName) = @_;
+    my $dartInterfaceName = DartInterfaceName($interfaceName);
     my $descriptor = NativeBindingDescriptor->new(
         cppCallbackName => "${attributeName}Setter",
-        nativeId => "${interfaceName}_${attributeName}_Setter",
+        nativeId => "${dartInterfaceName}_${attributeName}_Setter",
         argumentCount => 2);
     push(@dartNatives, $descriptor);
     return $descriptor;
 }
 
 sub GenerateDartOptionalArgumentsResolver
 {
     my ($interfaceName, $function) = @_;
 
     my $interfaceMethodDeclaration = DartInterfaceMethodDeclaration($interfaceName, $function);
@@ skipping 275 matching lines @@
             push(@dartImplContent, <<END);
   $implementationClassName.fromBuffer(ArrayBuffer buffer, [int start, int length]) {
     this._bind(buffer, start, length);
   }
   $implementationClassName.fromList(List<num> list) {
     this._bind(list, null, null);
   }
 END
         }
         if (HasCustomConstructor($dataNode)) {
-           my $descriptor = CreateFunctionNativeDescriptor($interfaceName, "constructor", 1 + $parameterCount);
+           my $descriptor = CreateFunctionNativeDescriptor($interfaceName, "constructor", $parameterCount);
            my $nativeId = $descriptor->nativeId;
            push(@dartImplContent, "  void _bind($arguments) native \"$nativeId\";\n");
         } else {
             push(@dartImplContent, "  void _bind($arguments) { /* FIXME: bind to the real object */ throw 'Binding unimplemented'; }\n");
         }
     }
 
     # Generate implementation support.
     # FIXME: get rid of implementation support completely.
     push(@dartImplContent, <<END);
@@ skipping 99 matching lines @@
         push(@dartInterfaceContent, "  $subscriptOperatorDeclaration;\n");
         push(@dartImplContent, "  $subscriptOperatorDeclaration { return item($parameters); }\n");
     }
 }
 
 sub GenerateNativeBinding
 {
     my ($interfaceName, $function, $parameters) = @_;
 
     my $functionName = DartName($interfaceName, $function->signature->name);
-    if (HasOverloads($function)) {
-        $functionName .= $function->{overloadIndex};
+    my $index = 0;
+    foreach my $overload (@{$function->{overloads}}) {
+        $index += 1;
+        last if $overload == $function;
+        foreach my $parameter (@{$overload->parameters}) {
+            $index += 1 if IsParameterOptionalInWebKit($parameter);
+        }
     }
-    if (HasOptionalParameters($function)) {
-        $functionName .= "_" . @$parameters;
+    my $mandatoryParameterCount = 0;
+    foreach my $parameter (@{$function->parameters}) {
+        last if IsParameterOptionalInWebKit($parameter);
+        $mandatoryParameterCount += 1;
+    }
+    $index += @{$parameters} - $mandatoryParameterCount;
+    if ($index != 1) {
+        $functionName .= "_" . $index;
     }
 
     my $extendedAttributes = $function->signature->extendedAttributes;
     my $returnType = $function->signature->type;
 
     my $dartParameters = DartParameters($function, $parameters, 0);
     my $dartParameterCount = DartParameterCount($function, $parameters);
     my $methodDeclaration = DartMethodDeclaration($functionName, $dartParameters, $returnType);
     my $descriptor = CreateFunctionNativeDescriptor($interfaceName, $functionName, 1 + $dartParameterCount);
     my $nativeId = $descriptor->nativeId;
@@ skipping 37 matching lines @@
     }
 
     if (defined($HEADER)) {
         # Write content to file.
         print $HEADER @headerContent;
         close($HEADER);
         undef($HEADER);
 
         @headerContent = ();
     }
-
-    if (defined($DART_INTERFACE)) {
-      # Write content of Dart file.
-      print $DART_INTERFACE @dartInterfaceContent;
-      close($DART_INTERFACE);
-      undef($DART_INTERFACE);
-
-      @dartInterfaceContent = ();
-    }
-
-    if (defined($DART_IMPL)) {
-      # Write content of Dart file.
-      print $DART_IMPL @dartImplContent;
-      close($DART_IMPL);
-      undef($DART_IMPL);
-
-      @dartImplContent = ();
-    }
 }