Clean up #includes in generated header files

Source/bindings/scripts/CodeGeneratorV8.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, 2012 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)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 111 matching lines @@
 my $verbose;
 my $dependentIdlFiles;
 my $writeFileOnlyIfChanged;
 my $sourceRoot;
 
 # Cache of IDL file pathnames.
 my $idlFiles;
 my $cachedInterfaces = {};
 
 my %implIncludes = ();
-my %headerIncludeFiles = ();
+my %headerIncludes = ();
 
 # Header code structure:
 # Root                    ... Copyright, include duplication check
 #   Conditional           ... #if FEATURE ... #endif  (to be removed soon)
 #     Includes
 #     NameSpaceWebCore
 #       Class
 #         ClassPublic
 #         ClassPrivate
 my %header;
@@ skipping 115 matching lines @@
         my $wanted = sub {
             $idlFiles->{$1} = $File::Find::name if /^([A-Z].*)\.idl$/;
             $File::Find::prune = 1 if /^\../;
         };
         find($wanted, @directories);
     }
 
     return $idlFiles->{$interfaceName};
 }
 
-sub HeaderFileForInterface
-{
-    my $interfaceName = shift;
-    my $implClassName = shift || $interfaceName;
-
-    my $idlFilename = IDLFileForInterface($interfaceName)
-        or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
-
-    my $idlRelPath= "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
-    return dirname($idlRelPath) . "/" . $implClassName . ".h";
-}
-
 sub ParseInterface
 {
     my $interfaceName = shift;
 
     return undef if $interfaceName eq 'Object';
 
     if (exists $cachedInterfaces->{$interfaceName}) {
         return $cachedInterfaces->{$interfaceName};
     }
 
@@ skipping 108 matching lines @@
             foreach my $condition (split(/\|/, $oldValue)) {
                 $newValue{$condition} = 1;
             }
             $implIncludes{$header} = join("|", sort keys %newValue);
         }
     }
 }
 
 sub AddToHeaderIncludes
 {
-    my $header = shift;
-    $headerIncludeFiles{$header} = 1;
+    my @includes = @_;
+
+    for my $include (@includes) {
+        $headerIncludes{$include} = 1;
+    }
 }
 
 sub SkipIncludeHeader
 {
     my $type = shift;
 
     return 1 if IsPrimitiveType($type);
     return 1 if IsEnumType($type);
     return 1 if $type eq "DOMString";
 
@@ skipping 18 matching lines @@
     } else {
         AddToImplIncludes("V8${type}.h");
     }
 
     # Additional includes
     if ($type eq "CSSStyleSheet") {
         AddToImplIncludes("core/css/CSSImportRule.h");
     }
 }
 
+sub HeaderFilesForInterface
+{
+    my $interfaceName = shift;
+    my $implClassName = shift;
+
+    my @includes = ();
+    if (IsTypedArrayType($interfaceName)) {
+        push(@includes, "wtf/${interfaceName}.h");
+    } elsif ($interfaceName =~ /SVGPathSeg/) {
+        $interfaceName =~ s/Abs|Rel//;
+        push(@includes, "core/svg/${interfaceName}.h");
+    } elsif (!SkipIncludeHeader($interfaceName)) {
+        my $idlFilename = IDLFileForInterface($interfaceName) or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
+        my $idlRelPath= "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
+        push(@includes, dirname($idlRelPath) . "/" . $implClassName . ".h");
+    }
+    return @includes;
+}
+
 sub NeedsCustomOpaqueRootForGC
 {
     my $interface = shift;
     return GetGenerateIsReachable($interface) || GetCustomIsReachable($interface);
 }
 
 sub GetGenerateIsReachable
 {
     my $interface = shift;
     return $interface->extendedAttributes->{"GenerateIsReachable"} || ""
@@ skipping 61 matching lines @@
     $svgNativeType = GetSVGTypeNeedingTearOff($implType);
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType) if not $svgNativeType;
 
     # Append space to avoid compilation errors when using  PassRefPtr<$svgNativeType>
     $svgNativeType = "$svgNativeType ";
 
     my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($implType);
     if ($svgNativeType =~ /SVGPropertyTearOff/) {
         $svgPropertyType = $svgWrappedNativeType;
         AddToImplIncludes("core/svg/properties/SVGAnimatedPropertyTearOff.h");
-    } elsif ($svgNativeType =~ /SVGListPropertyTearOff/ or $svgNativeType =~ /SVGStaticListPropertyTearOff/) {
+    } elsif ($svgNativeType =~ /SVGListPropertyTearOff/ or $svgNativeType =~ /SVGStaticListPropertyTearOff/ or $svgNativeType =~ /SVGTransformListPropertyTearOff/) {
         $svgListPropertyType = $svgWrappedNativeType;
         AddToHeaderIncludes("core/svg/properties/SVGAnimatedListPropertyTearOff.h");
-        AddToHeaderIncludes("core/svg/properties/SVGStaticListPropertyTearOff.h");
-    } elsif ($svgNativeType =~ /SVGTransformListPropertyTearOff/) {
-        $svgListPropertyType = $svgWrappedNativeType;
-        AddToHeaderIncludes("core/svg/properties/SVGAnimatedListPropertyTearOff.h");
-        AddToHeaderIncludes("core/svg/properties/SVGTransformListPropertyTearOff.h");
     } elsif ($svgNativeType =~ /SVGPathSegListPropertyTearOff/) {
         $svgListPropertyType = $svgWrappedNativeType;
         AddToHeaderIncludes("core/svg/properties/SVGPathSegListPropertyTearOff.h");
     }
 
     if ($svgPropertyType) {
         $svgPropertyType = "SVGPoint" if $svgPropertyType eq "FloatPoint";
     }
 
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType);
@@ skipping 54 matching lines @@
     my $v8ClassName = GetV8ClassName($interface);
 
     # Copy contents of parent interfaces except the first parent.
     my @parents;
     AddMethodsConstantsAndAttributesFromParentInterfaces($interface, \@parents, 1);
     LinkOverloadedFunctions($interface);
 
     # Ensure the IsDOMNodeType function is in sync.
     die("IsDOMNodeType is out of date with respect to $interfaceName") if IsDOMNodeType($interfaceName) != InheritsInterface($interface, "Node");
 
+    my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
+
     my $hasDependentLifetime = $interface->extendedAttributes->{"DependentLifetime"} || InheritsExtendedAttribute($interface, "ActiveDOMObject") || GetGenerateIsReachable($interface) || $v8ClassName =~ /SVG/;
     if (!$hasDependentLifetime) {
         foreach (@{$interface->parents}) {
             my $parent = $_;
             AddToHeaderIncludes("V8${parent}.h");
         }
     }
 
     AddToHeaderIncludes("bindings/v8/WrapperTypeInfo.h");
     AddToHeaderIncludes("bindings/v8/V8Binding.h");
     AddToHeaderIncludes("bindings/v8/V8DOMWrapper.h");
-    AddToHeaderIncludes("v8.h");
-    AddToHeaderIncludes("wtf/HashMap.h");
-    AddToHeaderIncludes("wtf/text/StringHash.h");
-
-    my $headerClassInclude = GetHeaderClassInclude($interfaceName, $implClassName);
-    AddToHeaderIncludes($headerClassInclude) if $headerClassInclude;
-
-    my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
-
-    foreach my $headerInclude (sort keys(%headerIncludeFiles)) {
-        $header{includes}->add("#include \"${headerInclude}\"\n") unless $headerInclude =~ /v8\.h/;
+    AddToHeaderIncludes(HeaderFilesForInterface($interfaceName, $implClassName));
+    foreach my $headerInclude (sort keys(%headerIncludes)) {
+        $header{includes}->add("#include \"${headerInclude}\"\n");
     }
-    $header{includes}->add("#include \<v8.h\>\n") if $headerIncludeFiles{"v8.h"};
 
     $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGPropertyTearOff;\n") if $svgPropertyType;
     if ($svgNativeType) {
         if ($svgNativeType =~ /SVGStaticListPropertyTearOff/) {
             $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGStaticListPropertyTearOff;\n");
         } else {
             $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGListPropertyTearOff;\n");
         }
     }
 
@@ skipping 18 matching lines @@
     my $code = "";
     $code .= "    static const bool hasDependentLifetime = ";
     if ($hasDependentLifetime) {
         $code .= "true;\n";
     } elsif (@{$interface->parents}) {
         # Even if this type doesn't have the [DependentLifetime] attribute its parents may.
         # Let the compiler statically determine this for us.
         my $separator = "";
         foreach (@{$interface->parents}) {
             my $parent = $_;
-            AddToHeaderIncludes("V8${parent}.h");
             $code .= "${separator}V8${parent}::hasDependentLifetime";
             $separator = " || ";
         }
         $code .= ";\n";
     } else {
         $code .= "false;\n";
     }
     $header{classPublic}->add($code);
 
     my $fromFunctionOpening = "";
@@ skipping 295 matching lines @@
 
     my @customInternalFields = ();
     # Event listeners on DOM nodes are explicitly supported in the GC controller.
     if (!InheritsInterface($interface, "Node") &&
         InheritsExtendedAttribute($interface, "EventTarget")) {
         push(@customInternalFields, "eventListenerCacheIndex");
     }
     return @customInternalFields;
 }
 
-sub GetHeaderClassInclude
-{
-    my $interfaceName = shift;
-    my $implClassName = shift;
-
-    if ($interfaceName =~ /SVGPathSeg/) {
-        $interfaceName =~ s/Abs|Rel//;
-        return "core/svg/${interfaceName}.h";
-    }
-    return "wtf/${interfaceName}.h" if IsTypedArrayType($interfaceName);
-    return "" if (SkipIncludeHeader($interfaceName));
-    return HeaderFileForInterface($interfaceName, $implClassName);
-}
-
 sub GenerateHeaderCustomInternalFieldIndices
 {
     my $interface = shift;
     my @customInternalFields = GetInternalFields($interface);
     my $customFieldCounter = 0;
     foreach my $customInternalField (@customInternalFields) {
         $header{classPublic}->add(<<END);
     static const int ${customInternalField} = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
 END
         $customFieldCounter++;
@@ skipping 445 matching lines @@
 
     my $returnType = $attribute->signature->type;
     my $getterString;
 
     if ($getterStringUsesImp) {
         my ($functionName, @arguments) = GetterExpression(\%implIncludes, $interfaceName, $attribute);
         push(@arguments, "isNull") if $isNullable;
         push(@arguments, "ec") if $useExceptions;
         if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
             my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
-            AddToImplIncludes(HeaderFileForInterface($implementedBy));
+            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
             unshift(@arguments, "imp") if !$attribute->isStatic;
             $functionName = "${implementedBy}::${functionName}";
         } elsif ($attribute->isStatic) {
             $functionName = "${implClassName}::${functionName}";
         } else {
             $functionName = "imp->${functionName}";
         }
         my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 0);
         $code .= $subCode;
         unshift(@arguments, @$arg);
@@ skipping 418 matching lines @@
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::getEventListener(value, true, ListenerFindOrCreate)";
             }
             $code .= ", ec" if $useExceptions;
             $code .= ");\n";
         } else {
             my ($functionName, @arguments) = SetterExpression(\%implIncludes, $interfaceName, $attribute);
             push(@arguments, $expression);
             push(@arguments, "ec") if $useExceptions;
             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
-                AddToImplIncludes(HeaderFileForInterface($implementedBy));
+                AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
                 unshift(@arguments, "imp") if !$attribute->isStatic;
                 $functionName = "${implementedBy}::${functionName}";
             } elsif ($attribute->isStatic) {
                 $functionName = "${implClassName}::${functionName}";
             } else {
                 $functionName = "imp->${functionName}";
             }
             my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 1);
             $code .= $subCode;
             unshift(@arguments, @$arg);
@@ skipping 1654 matching lines @@
     if (@{$interface->constants}) {
         $has_constants = 1;
         $code .= "static const V8DOMConfiguration::BatchedConstant ${v8ClassName}Consts[] = {\n";
     }
     foreach my $constant (@{$interface->constants}) {
         my $name = $constant->name;
         my $value = $constant->value;
         my $attrExt = $constant->extendedAttributes;
         my $implementedBy = $attrExt->{"ImplementedBy"};
         if ($implementedBy) {
-            AddToImplIncludes(HeaderFileForInterface($implementedBy));
+            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
             push(@constantsEnabledAtRuntime, $constant);
         } else {
             my $conditionalString = GenerateConditionalString($constant);
             $code .= "#if ${conditionalString}\n" if $conditionalString;
             # If the value we're dealing with is a hex number, preprocess it into a signed integer
             # here, rather than running static_cast<signed int> in the generated code.
             if (substr($value, 0, 2) eq "0x") {
               $value = unpack('i', pack('I', hex($value)));
@@ skipping 390 matching lines @@
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplClassName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     $header{root}->addFooter("\n");
 
-    my @unsortedIncludes = ();
-    push(@unsortedIncludes, "#include \"bindings/v8/ActiveDOMCallback.h\"");
-    push(@unsortedIncludes, "#include \"bindings/v8/DOMWrapperWorld.h\"");
-    push(@unsortedIncludes, "#include \"bindings/v8/ScopedPersistent.h\"");
-    my $interfaceHeader = HeaderFileForInterface($interfaceName, $implClassName);
-    push(@unsortedIncludes, "#include \"$interfaceHeader\"");
-    push(@unsortedIncludes, "#include <v8.h>");
-    push(@unsortedIncludes, "#include \"wtf/Forward.h\"");
-    $header{includes}->add(join("\n", sort @unsortedIncludes));
-    unshift(@{$header{nameSpaceWebCore}->{header}}, "\n");
-    $header{nameSpaceWebCore}->addHeader("class ScriptExecutionContext;\n\n");
+    my @includes = ();
+    push(@includes, "bindings/v8/ActiveDOMCallback.h");
+    push(@includes, "bindings/v8/DOMWrapperWorld.h");
+    push(@includes, "bindings/v8/ScopedPersistent.h");
+    push(@includes, HeaderFilesForInterface($interfaceName, $implClassName));
+    for my $include (sort @includes) {
+        $header{includes}->add("#include \"$include\"\n");
+    }
+    $header{nameSpaceWebCore}->addHeader("\nclass ScriptExecutionContext;\n\n");
     $header{class}->addHeader("class $v8ClassName : public $implClassName, public ActiveDOMCallback {");
     $header{class}->addFooter("};\n");
 
     $header{classPublic}->add(<<END);
     static PassRefPtr<${v8ClassName}> create(v8::Handle<v8::Value> value, ScriptExecutionContext* context)
     {
         ASSERT(value->IsObject());
         ASSERT(context);
         return adoptRef(new ${v8ClassName}(v8::Handle<v8::Object>::Cast(value), context));
     }
@@ skipping 258 matching lines @@
     if ($function->signature->extendedAttributes->{"ImplementedAs"}) {
         $name = $function->signature->extendedAttributes->{"ImplementedAs"};
     }
 
     my $index = 0;
 
     my @arguments;
     my $functionName;
     my $implementedBy = $function->signature->extendedAttributes->{"ImplementedBy"};
     if ($implementedBy) {
-        AddToImplIncludes(HeaderFileForInterface($implementedBy));
+        AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
         unshift(@arguments, "imp") if !$function->isStatic;
         $functionName = "${implementedBy}::${name}";
     } elsif ($function->isStatic) {
         $functionName = "${implClassName}::${name}";
     } else {
         $functionName = "imp->${name}";
     }
 
     my $callWith = $function->signature->extendedAttributes->{"CallWith"};
     my ($callWithArgs, $subCode) = GenerateCallWith($callWith, $indent, 0, $function);
@@ skipping 1166 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;