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 21 matching lines @@
 use strict;
 
 use StaticString;
 use Config;
 use Getopt::Long;
 use File::Path;
 use File::Spec;
 use IO::File;
 use InFilesParser;
 
+use FindBin;                 # locate this script
+use lib "$FindBin::Bin/../../../../../third_party/WebKit/Source/bindings/scripts";  # use the binding generator directory.
+#use lib "$FindBin::Bin/../bindings/scripts";  # use the binding generator directory.
+use idltopath;
+
 sub readTags($$);
 sub readAttrs($$);
 
 my $printFactory = 0; 
 my $printWrapperFactory = 0; 
 my $printWrapperFactoryV8 = 0; 
 my $fontNamesIn = "";
 my $tagsFile = "";
 my $attrsFile = "";
 my $outputDir = ".";
@@ skipping 567 matching lines @@
 ";
 }
 
 sub printNamesHeaderFile
 {
     my ($headerPath) = shift;
     my $F;
     open F, ">$headerPath";
 
     printLicenseHeader($F);
-    printHeaderHead($F, "DOM", $parameters{namespace}, "#include \"QualifiedName.h\"");
+    printHeaderHead($F, "DOM", $parameters{namespace}, "#include \"core/dom/QualifiedName.h\"");
 
     my $lowerNamespace = lc($parameters{namespacePrefix});
     print F "// Namespace\n";
     print F "extern const WTF::AtomicString ${lowerNamespace}NamespaceURI;\n\n";
 
     if (keys %allTags) {
         print F "// Tags\n";
         printMacros($F, "extern const WebCore::QualifiedName", "Tag", \%allTags);
     }
 
@@ skipping 93 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 \"${wrapperFactoryType}${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/${wrapperFactoryType}${JSInterfaceName}.h\"\n";
     }
-    print F "#include \"${wrapperFactoryType}$parameters{fallbackInterfaceName}.h\"\n";
+    print F "#include \"bindings/${wrapperFactoryType}$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 = idl_to_path($interfaceName);
+        print F "#include \"$includepath${interfaceName}.h\"\n";
     }
     print F "#include \"$parameters{fallbackInterfaceName}.h\"\n";
 }
 
 sub printConditionalElementIncludes
 {
     my ($F, $wrapperFactoryType) = @_;
 
     my %conditionals;
     my %unconditionalElementIncludes;
@@ skipping 73 matching lines @@
 ;
 
 printElementIncludes($F);
 
 print F "\n#include <wtf/HashMap.h>\n";
 
 printConditionalElementIncludes($F);
 
 print F <<END
 
-#include "ContextFeatures.h"
-#include "RuntimeEnabledFeatures.h"
+#include "core/dom/ContextFeatures.h"
+#include "core/page/RuntimeEnabledFeatures.h"
 
 #if ENABLE(CUSTOM_ELEMENTS)
 #include "CustomElementConstructor.h"
 #include "CustomElementRegistry.h"
 #endif
 
 #if ENABLE(VIDEO)
-#include "Document.h"
-#include "Settings.h"
+#include "core/dom/Document.h"
+#include "core/page/Settings.h"
 #endif
 
 namespace WebCore {
 
 using namespace $parameters{namespace}Names;
 
 END
 ;
 
 print F "typedef PassRefPtr<$parameters{namespace}Element> (*ConstructorFunction)(const QualifiedName&, Document*";
@@ skipping 302 matching lines @@
     print F "\n#include \"$parameters{namespace}Names.h\"\n\n";
 
     printElementIncludes($F);
 
     print F "\n#include <wtf/StdLibExtras.h>\n";
 
     printConditionalElementIncludes($F, $wrapperFactoryType);
 
     print F <<END
 
-#include "ContextFeatures.h"
-#include "RuntimeEnabledFeatures.h"
+#include "core/dom/ContextFeatures.h"
+#include "core/page/RuntimeEnabledFeatures.h"
 
 #if ENABLE(VIDEO)
-#include "Document.h"
-#include "Settings.h"
+#include "core/dom/Document.h"
+#include "core/page/Settings.h"
 #endif
 
 END
 ;
 
     if ($wrapperFactoryType eq "V8") {
         print F <<END
 #include "V8$parameters{namespace}Element.h"
 
 #if ENABLE(CUSTOM_ELEMENTS)
-#include "CustomElementHelpers.h"
+#include "bindings/v8/CustomElementHelpers.h"
 #endif
 
 #include <v8.h>
 END
 ;
     }
 
     print F <<END
 
 namespace WebCore {
@@ skipping 168 matching lines @@
 
     printLicenseHeader($F);
 
     print F "#ifndef $wrapperFactoryType$parameters{namespace}ElementWrapperFactory_h\n";
     print F "#define $wrapperFactoryType$parameters{namespace}ElementWrapperFactory_h\n\n";
 
     print F "#if $parameters{guardFactoryWith}\n" if $parameters{guardFactoryWith};
 
     if ($wrapperFactoryType eq "V8") {
         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 // $wrapperFactoryType$parameters{namespace}ElementWrapperFactory_h\n";
 
     close F;
 }