Fixes to make scripts generate includes with paths.

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 20 matching lines @@
 
 use strict;
 
 use StaticString;
 use Config;
 use Getopt::Long;
 use File::Path;
 use File::Spec;
 use IO::File;
 use InFilesParser;
+use idltopath;
 
 sub readTags($$);
 sub readAttrs($$);
 
 my $printFactory = 0; 
+my $idlToPathFile = "";
 my $fontNamesIn = "";
 my $tagsFile = "";
 my $attrsFile = "";
 my $outputDir = ".";
 my %parsedTags = ();
 my %parsedAttrs = ();
 my %enabledTags = ();
 my %enabledAttrs = ();
 my %allTags = ();
 my %allAttrs = ();
@@ skipping 15 matching lines @@
 }
 my $preprocessor = $gccLocation . " -E -x c++";
 
 GetOptions(
     'tags=s' => \$tagsFile, 
     'attrs=s' => \$attrsFile,
     'factory' => \$printFactory,
     'outputDir=s' => \$outputDir,
     'extraDefines=s' => \$extraDefines,
     'preprocessor=s' => \$preprocessor,
+    'idltopathfile=s' => \$idlToPathFile,
     'fonts=s' => \$fontNamesIn
 );
 
+initIdlToPath($idlToPathFile);
+
 mkpath($outputDir);
 
 if (length($fontNamesIn)) {
     my $names = new IO::File;
     my $familyNamesFileBase = "WebKitFontFamily";
 
     open($names, $fontNamesIn) or die "Failed to open file: $fontNamesIn";
 
     $initDefaults = 0;
     my $Parser = InFilesParser->new();
@@ skipping 437 matching lines @@
 {
     my ($F, $prefix, $nsName, $usedNamespace) = @_;
 
     print F "#include \"config.h\"\n\n";
     print F "#ifdef SKIP_STATIC_CONSTRUCTORS_ON_GCC\n";
     print F "#define ${prefix}_${nsName}NAMES_HIDE_GLOBALS 1\n";
     print F "#else\n";
     print F "#define QNAME_DEFAULT_CONSTRUCTOR 1\n";
     print F "#endif\n\n";
 
-    print F "#include \"${nsName}Names.h\"\n\n";
+    print F "#include \"./././${nsName}Names.h\"\n\n";
     print F "#include <wtf/StaticConstructors.h>\n";
 
     print F "namespace WebCore {\n\n";
     print F "namespace ${nsName}Names {\n\n";
     print F "using namespace $usedNamespace;\n\n";
 }
 
 sub printInit
 {
     my ($F, $isDefinition) = @_;
@@ skipping 166 matching lines @@
     my %tagsSeen;
     for my $tagName (sort keys %enabledTags) {
         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";
+        # V8HTMLElementWrapperFactory.cpp that uses this code is generated into "webkit" and for instance V8HTMLAnchorElement.h is in "webkit/bindings"
+        print F "#include \"bindings/V8${JSInterfaceName}.h\"\n";
     }
-    print F "#include \"V8$parameters{fallbackInterfaceName}.h\"\n";
+    print F "#include \"bindings/V8$parameters{fallbackInterfaceName}.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});
         if ($enabledTags{$tagName}{conditional}) {
             # We skip feature-define-specific #includes here since we handle them separately.
             next;
         }
         $tagsSeen{$interfaceName} = 1;
 
-        print F "#include \"${interfaceName}.h\"\n";
+        my $includepath = idlToPath($interfaceName);
+        print F "#include \"$includepath${interfaceName}.h\"\n";
     }
-    print F "#include \"$parameters{fallbackInterfaceName}.h\"\n";
+    my $fallbackInterface = $parameters{fallbackInterfaceName};
+    if ($fallbackInterface) {
+        my $fallbackInterfacePath = idlToPath($fallbackInterface);
+        print F "#include \"$fallbackInterfacePath$fallbackInterface.h\"\n";
+    }
 }
 
 sub printConditionalElementIncludes
 {
     my ($F, $shouldIncludeV8Headers) = @_;
 
     my %conditionals;
     my %unconditionalElementIncludes;
     my %unconditionalJSElementIncludes;
 
     for my $tagName (keys %enabledTags) {
         my $conditional = $enabledTags{$tagName}{conditional};
         my $interfaceName = $enabledTags{$tagName}{interfaceName};
         my $JSInterfaceName = $enabledTags{$tagName}{JSInterfaceName};
 
         if ($conditional) {
             $conditionals{$conditional}{interfaceNames}{$interfaceName} = 1;
             $conditionals{$conditional}{JSInterfaceNames}{$JSInterfaceName} = 1;
         } else {
             $unconditionalElementIncludes{$interfaceName} = 1;
             $unconditionalJSElementIncludes{$JSInterfaceName} = 1;
         }
     }
 
     for my $conditional (sort keys %conditionals) {
         print F "\n#if ENABLE($conditional)\n";
         for my $interfaceName (sort keys %{$conditionals{$conditional}{interfaceNames}}) {
             next if $unconditionalElementIncludes{$interfaceName};
-            print F "#include \"$interfaceName.h\"\n";
+            my $interfacePath = idlToPath($interfaceName);
+            print F "#include \"$interfacePath/$interfaceName.h\"\n";
         }
         if ($shouldIncludeV8Headers) {
             for my $JSInterfaceName (sort keys %{$conditionals{$conditional}{JSInterfaceNames}}) {
                 next if $unconditionalJSElementIncludes{$JSInterfaceName};
                 print F "#include \"V8$JSInterfaceName.h\"\n";
             }
         }
         print F "#endif\n";
     }
 }
@@ skipping 42 matching lines @@
 ;
 
 printElementIncludes($F);
 
 print F "\n#include <wtf/HashMap.h>\n";
 
 printConditionalElementIncludes($F);
 
 print F <<END
 
-#include "ContextFeatures.h"
-#include "Document.h"
+#include "core/dom/ContextFeatures.h"
+#include "core/dom/Document.h"
+#include "core/page/Settings.h"
 #include "RuntimeEnabledFeatures.h"
-#include "Settings.h"
 
 #include "CustomElementRegistry.h"
 
 namespace WebCore {
 
 using namespace $parameters{namespace}Names;
 
 END
 ;
 
@@ skipping 239 matching lines @@
     print F "\n#include \"$parameters{namespace}Names.h\"\n\n";
 
     printElementIncludes($F);
 
     print F "\n#include <wtf/StdLibExtras.h>\n";
 
     printConditionalElementIncludes($F, 1);
 
     print F <<END
 
-#include "ContextFeatures.h"
-#include "Document.h"
+#include "core/dom/ContextFeatures.h"
+#include "core/dom/Document.h"
+#include "core/page/Settings.h"
 #include "RuntimeEnabledFeatures.h"
-#include "Settings.h"
 
 #include "V8$parameters{namespace}Element.h"
 
 #include "bindings/v8/CustomElementHelpers.h"
 
 #include <v8.h>
 
 namespace WebCore {
 
 using namespace $parameters{namespace}Names;
@@ skipping 115 matching lines @@
     open F, ">" . $outputDir . "/V8" . $wrapperFactoryFileName . ".h";
 
     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 "bindings/V8$parameters{namespace}Element.h"
+#include "bindings/V8$parameters{fallbackInterfaceName}.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)
     {
         return V8$parameters{fallbackInterfaceName}::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;
 }