Generate toFooElement() functions from tagname data

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.
+# Copyright (C) 2013 Samsung Electronics. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1.  Redistributions of source code must retain the above copyright
 #     notice, this list of conditions and the following disclaimer.
 # 2.  Redistributions in binary form must reproduce the above copyright
 #     notice, this list of conditions and the following disclaimer in the
 #     documentation and/or other materials provided with the distribution.
@@ skipping 93 matching lines @@
     %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 $typeHelpersBasePath = "$outputDir/$parameters{namespace}ElementTypeHelpers";
 my $namesBasePath = "$outputDir/$parameters{namespace}Names";
 my $factoryBasePath = "$outputDir/$parameters{namespace}ElementFactory";
 my $wrapperFactoryFileName = "$parameters{namespace}ElementWrapperFactory";
 
 printNamesHeaderFile("$namesBasePath.h");
 printNamesCppFile("$namesBasePath.cpp");
+printTypeHelpersHeaderFile("$typeHelpersBasePath.h");
 
 if ($printFactory) {
     printFactoryCppFile("$factoryBasePath.cpp");
     printFactoryHeaderFile("$factoryBasePath.h");
 }
 
 printWrapperFactoryCppFile($outputDir, $wrapperFactoryFileName);
 printWrapperFactoryHeaderFile($outputDir, $wrapperFactoryFileName);
 
 ### Hash initialization
 
 sub defaultTagPropertyHash
 {
     return (
         'constructorNeedsCreatedByParser' => 0,
         'constructorNeedsFormElement' => 0,
         'noConstructor' => 0,
         'interfaceName' => defaultInterfaceName($_[0]),
         # By default, the JSInterfaceName is the same as the interfaceName.
         'JSInterfaceName' => defaultInterfaceName($_[0]),
         'mapToTagName' => '',
         'wrapperOnlyIfMediaIsAvailable' => 0,
         'conditional' => 0,
         'contextConditional' => 0,
-        'runtimeConditional' => 0
+        'runtimeConditional' => 0,
+        'generateTypeHelpers' => 0
     );
 }
 
 sub defaultParametersHash
 {
     return (
         'namespace' => '',
         'namespacePrefix' => '',
         'namespaceURI' => '',
         'guardFactoryWith' => '',
@@ skipping 402 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 ";
 }
 
+sub printTypeHelpers
+{
+    my ($F, $namesRef) = @_;
+    my %names = %$namesRef;
+
+    for my $name (sort keys %names) {
+        if (!$parsedTags{$name}{generateTypeHelpers}) {
+            next;
+        }
+
+        my $class = $parsedTags{$name}{interfaceName};
+        my $castingHelper = "to$class";
+
+        print F "class $class;\n";
+        print F "inline $class* $castingHelper(Node* node) { ASSERT_WITH_SECURITY_IMPLICATION(!node || node->hasTagName(".$parameters{namespace}."Names::".$name."Tag)); return reinterpret_cast<".$class."*>(node); }\n";

[tkent, 2013/09/09 05:53:39]

If we used reinterpret_cast<>, we should have a way to enforce Blink developers
to write class definitions which work well with reinterpret_cast.  I'm not sure
if it will be acceptable to the developers.

+        print F "inline $class* $castingHelper(Element* element) { ASSERT_WITH_SECURITY_IMPLICATION(!element || element->hasTagName(".$parameters{namespace}."Names::".$name."Tag)); return reinterpret_cast<".$class."*>(element); }\n";
+
+        print F "\n";
+    }
+}
+
+sub printTypeHelpersHeaderFile
+{
+    my ($headerPath) = shift;
+    my $F;
+    open F, ">$headerPath";
+    printLicenseHeader($F);
+
+    print F "#ifndef ".$parameters{namespace}."ElementTypeHelpers_h\n";
+    print F "#define ".$parameters{namespace}."ElementTypeHelpers_h\n\n";
+    print F "#include \"".$parameters{namespace}."Names.h\"\n";
+    print F "#include \"core/dom/Element.h\"\n";
+    print F "#include \"core/dom/Node.h\"\n\n";
+    print F "namespace WebCore {\n";
+
+    printTypeHelpers($F, \%allTags);
+
+    print F "}\n\n";
+    print F "#endif\n";
+
+    close F;
+}
+
 sub printNamesHeaderFile
 {
     my ($headerPath) = shift;
     my $F;
     open F, ">$headerPath";
 
     printLicenseHeader($F);
     printHeaderHead($F, "DOM", $parameters{namespace}, "#include \"core/dom/QualifiedName.h\"");
 
     my $lowerNamespace = lc($parameters{namespacePrefix});
@@ skipping 690 matching lines @@
     print F StaticString::GenerateStringImpls(\%parameters);
 
     while ( my ($name, $identifier) = each %parameters ) {
         print F "    new ((void*)&$name) AtomicString(${name}Impl);\n";
     }
 
     print F "}\n}\n}\n";
     close F;
     exit 0;
 }