Introduce a SVGUnknownElement class for unknown SVG elements

Source/core/scripts/make_names.pl

 #!/usr/bin/perl -w
 
 # Copyright (C) 2005, 2006, 2007, 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2009, Julien Chaffraix <jchaffraix@webkit.org>
 # Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
 # Copyright (C) 2011 Ericsson AB. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
@@ skipping 97 matching lines @@
 if (length($attrsFile)) {
     %allAttrs = %{readAttrs($attrsFile, 0)};
     %enabledAttrs = %{readAttrs($attrsFile, 1)};
     namesToStrings(\%allAttrs, \%allStrings);
 }
 
 die "You must specify a namespace (e.g. SVG) for <namespace>Names.h" unless $parameters{namespace};
 die "You must specify a namespaceURI (e.g. http://www.w3.org/2000/svg)" unless $parameters{namespaceURI};
 
 $parameters{namespacePrefix} = $parameters{namespace} unless $parameters{namespacePrefix};
+$parameters{fallbackJSInterfaceName} = $parameters{fallbackInterfaceName} unless $parameters{fallbackJSInterfaceName};
 
 my $namesBasePath = "$outputDir/$parameters{namespace}Names";
 my $factoryBasePath = "$outputDir/$parameters{namespace}ElementFactory";
 my $wrapperFactoryFileName = "$parameters{namespace}ElementWrapperFactory";
 
 printNamesHeaderFile("$namesBasePath.h");
 printNamesCppFile("$namesBasePath.cpp");
 
 if ($printFactory) {
     printFactoryCppFile("$factoryBasePath.cpp");
@@ skipping 24 matching lines @@
 
 sub defaultParametersHash
 {
     return (
         'namespace' => '',
         'namespacePrefix' => '',
         'namespaceURI' => '',
         'guardFactoryWith' => '',
         'tagsNullNamespace' => 0,
         'attrsNullNamespace' => 0,
-        'fallbackInterfaceName' => ''
+        'fallbackInterfaceName' => '',
+        'fallbackJSInterfaceName' => ''
     );
 }
 
 sub defaultInterfaceName
 {
     die "No namespace found" if !$parameters{namespace};
     return $parameters{namespace} . upperCaseName($_[0]) . "Element"
 }
 
 ### Parsing handlers
@@ skipping 510 matching lines @@
         my $JSInterfaceName = $enabledTags{$tagName}{JSInterfaceName};
         next if defined($tagsSeen{$JSInterfaceName}) || usesDefaultJSWrapper($tagName);
         if ($enabledTags{$tagName}{conditional}) {
             # We skip feature-define-specific #includes here since we handle them separately.
             next;
         }
         $tagsSeen{$JSInterfaceName} = 1;
 
         print F "#include \"V8${JSInterfaceName}.h\"\n";
     }
-    print F "#include \"V8$parameters{fallbackInterfaceName}.h\"\n";
+    print F "#include \"V8$parameters{fallbackJSInterfaceName}.h\"\n";
 }
 
 sub printElementIncludes
 {
     my $F = shift;
 
     my %tagsSeen;
     for my $tagName (sort keys %enabledTags) {
         my $interfaceName = $enabledTags{$tagName}{interfaceName};
         next if defined($tagsSeen{$interfaceName});
@@ skipping 255 matching lines @@
 }
 
 sub printWrapperFunctions
 {
     my $F = shift;
 
     my %tagsSeen;
     for my $tagName (sort keys %enabledTags) {
         # Avoid defining the same wrapper method twice.
         my $JSInterfaceName = $enabledTags{$tagName}{JSInterfaceName};
-        next if defined($tagsSeen{$JSInterfaceName}) || (usesDefaultJSWrapper($tagName) && ($parameters{fallbackInterfaceName} eq $parameters{namespace} . "Element"));
+        next if defined($tagsSeen{$JSInterfaceName}) || (usesDefaultJSWrapper($tagName) && ($parameters{fallbackJSInterfaceName} eq $parameters{namespace} . "Element"));
         $tagsSeen{$JSInterfaceName} = 1;
 
         my $conditional = $enabledTags{$tagName}{conditional};
         if ($conditional) {
             my $conditionalString = "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";
             print F "#if ${conditionalString}\n\n";
         }
 
         if ($enabledTags{$tagName}{wrapperOnlyIfMediaIsAvailable}) {
             print F <<END
@@ skipping 109 matching lines @@
 v8::Handle<v8::Object> createV8$parameters{namespace}Wrapper($parameters{namespace}Element* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     typedef HashMap<WTF::StringImpl*, Create$parameters{namespace}ElementWrapperFunction> FunctionMap;
     DEFINE_STATIC_LOCAL(FunctionMap, map, ());
     if (map.isEmpty()) {
 END
 ;
 
     for my $tag (sort keys %enabledTags) {
         # Do not add the name to the map if it does not have a JS wrapper constructor or uses the default wrapper.
-        next if (usesDefaultJSWrapper($tag, \%enabledTags) && ($parameters{fallbackInterfaceName} eq $parameters{namespace} . "Element"));
+        next if (usesDefaultJSWrapper($tag, \%enabledTags) && ($parameters{fallbackJSInterfaceName} eq $parameters{namespace} . "Element"));
 
         my $conditional = $enabledTags{$tag}{conditional};
         if ($conditional) {
             my $conditionalString = "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";
             print F "#if ${conditionalString}\n";
         }
 
         my $ucTag = $enabledTags{$tag}{JSInterfaceName};
         print F "       map.set(${tag}Tag.localName().impl(), create${ucTag}Wrapper);\n";
 
@@ skipping 86 matching lines @@
 
     printLicenseHeader($F);
 
     print F "#ifndef V8$parameters{namespace}ElementWrapperFactory_h\n";
     print F "#define V8$parameters{namespace}ElementWrapperFactory_h\n\n";
 
     print F "#if $parameters{guardFactoryWith}\n" if $parameters{guardFactoryWith};
 
     print F <<END
 #include <V8$parameters{namespace}Element.h>
-#include <V8$parameters{fallbackInterfaceName}.h>
+#include <V8$parameters{fallbackJSInterfaceName}.h>
 #include <v8.h>
 
 namespace WebCore {
 
     class $parameters{namespace}Element;
 
     const QualifiedName* find$parameters{namespace}TagNameOfV8Type(const WrapperTypeInfo*);
     v8::Handle<v8::Object> createV8$parameters{namespace}Wrapper($parameters{namespace}Element*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
     inline v8::Handle<v8::Object> createV8$parameters{namespace}DirectWrapper($parameters{namespace}Element* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
     {
         return V8$parameters{namespace}Element::createWrapper(element, creationContext, isolate);
     }
-    inline v8::Handle<v8::Object> createV8$parameters{namespace}FallbackWrapper($parameters{fallbackInterfaceName}* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+    inline v8::Handle<v8::Object> createV8$parameters{namespace}FallbackWrapper($parameters{fallbackJSInterfaceName}* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
     {
-        return V8$parameters{fallbackInterfaceName}::createWrapper(element, creationContext, isolate);
+        return V8$parameters{fallbackJSInterfaceName}::createWrapper(element, creationContext, isolate);
     }
 }
 END
 ;
     print F "#endif // $parameters{guardFactoryWith}\n\n" if $parameters{guardFactoryWith};
 
     print F "#endif // V8$parameters{namespace}ElementWrapperFactory_h\n";
 
     close F;
 }
@@ skipping 44 matching lines @@
 
     while ( my ($name, $identifier) = each %parameters ) {
         print F "    new ((void*)&$name) AtomicString(${name}Impl);\n";
     }
 
     print F "}\n}\n}\n";
     close F;
     exit 0;
 }