Fixes to make scripts generate includes with paths.

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 11 matching lines @@
 # You should have received a copy of the GNU Library General Public License
 # along with this library; see the file COPYING.LIB.  If not, write to
 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 #
 
 package CodeGeneratorV8;
 
 use strict;
 
+use idltopath;
+
 my $codeGenerator;
 
 
 my @headerContent = ();
 my @implContentHeader = ();
 my @implContent = ();
 my @implContentInternals = ();
 my %implIncludes = ();
 my %headerIncludes = ();
 
@@ skipping 96 matching lines @@
     if ($codeGenerator->IsTypedArrayType($type)) {
         AddToImplIncludes("wtf/${type}.h");
     }
     if (!$codeGenerator->IsPrimitiveType($type) and !$codeGenerator->IsStringType($type) and !$codeGenerator->SkipIncludeHeader($type) and $type ne "Date") {
         # default, include the same named file
         AddToImplIncludes(GetV8HeaderName(${type}));
 
         if ($type =~ /SVGPathSeg/) {
             my $joinedName = $type;
             $joinedName =~ s/Abs|Rel//;
-            AddToImplIncludes("${joinedName}.h");
+            AddToImplIncludes("core/svg/${joinedName}.h");
         }
     }
 
     # additional includes (things needed to compile the bindings but not the header)
 
     if ($type eq "CanvasRenderingContext2D") {
-        AddToImplIncludes("CanvasGradient.h");
-        AddToImplIncludes("CanvasPattern.h");
-        AddToImplIncludes("CanvasStyle.h");
+        AddToImplIncludes("core/html/canvas/CanvasGradient.h");
+        AddToImplIncludes("core/html/canvas/CanvasPattern.h");
+        AddToImplIncludes("core/html/canvas/CanvasStyle.h");
     }
 
     if ($type eq "CanvasGradient" or $type eq "XPathNSResolver") {
         AddToImplIncludes("wtf/text/WTFString.h");
     }
 
     if ($type eq "CSSStyleSheet" or $type eq "StyleSheet") {
-        AddToImplIncludes("CSSImportRule.h");
+        AddToImplIncludes("core/css/CSSImportRule.h");
     }
 
     if ($type eq "CSSStyleDeclaration") {
-        AddToImplIncludes("StylePropertySet.h");
+        AddToImplIncludes("core/css/StylePropertySet.h");
     }
 
     if ($type eq "Plugin" or $type eq "PluginArray" or $type eq "MimeTypeArray") {
         # So we can get String -> AtomicString conversion for namedItem().
         AddToImplIncludes("wtf/text/AtomicString.h");
     }
 }
 
 sub NeedsCustomOpaqueRootForGC
 {
@@ skipping 26 matching lines @@
 void* V8${interfaceName}::opaqueRootForGC(void* object, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
 {
     ASSERT(!wrapper.IsIndependent(isolate));
     ${interfaceName}* impl = static_cast<${interfaceName}*>(object);
 END
     if (GetGenerateIsReachable($interface) eq  "ImplDocument" ||
         GetGenerateIsReachable($interface) eq  "ImplElementRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerNodeRoot") {
 
-        $implIncludes{"V8GCController.h"} = 1;
+        $implIncludes{"bindings/v8/V8GCController.h"} = 1;

[abarth-chromium, 2013/04/25 14:14:24]

Why not use the header map for these headers as well?

[Daniel Bratell, 2013/04/25 21:24:26]

This is not an IDL interface name so these are not in that file. Also, since the
header file name is constant we don't need to calculate the position runtime.

 
         my $methodName;
         $methodName = "document" if (GetGenerateIsReachable($interface) eq "ImplDocument");
         $methodName = "element" if (GetGenerateIsReachable($interface) eq "ImplElementRoot");
         $methodName = "owner" if (GetGenerateIsReachable($interface) eq "ImplOwnerRoot");
         $methodName = "ownerNode" if (GetGenerateIsReachable($interface) eq "ImplOwnerNodeRoot");
 
         $code .= <<END;
     if (Node* owner = impl->${methodName}())
         return V8GCController::opaqueRootForGC(owner, isolate);
@@ skipping 20 matching lines @@
 
     $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($implType);
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType) if not $svgNativeType;
 
     # Append space to avoid compilation errors when using  PassRefPtr<$svgNativeType>
     $svgNativeType = "$svgNativeType ";
 
     my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implType);
     if ($svgNativeType =~ /SVGPropertyTearOff/) {
         $svgPropertyType = $svgWrappedNativeType;
-        AddToImplIncludes("SVGAnimatedPropertyTearOff.h");
+        AddToImplIncludes("core/svg/properties/SVGAnimatedPropertyTearOff.h");
     } elsif ($svgNativeType =~ /SVGListPropertyTearOff/ or $svgNativeType =~ /SVGStaticListPropertyTearOff/) {
         $svgListPropertyType = $svgWrappedNativeType;
-        $headerIncludes{"SVGAnimatedListPropertyTearOff.h"} = 1;
-        $headerIncludes{"SVGStaticListPropertyTearOff.h"} = 1;
+        $headerIncludes{"core/svg/properties/SVGAnimatedListPropertyTearOff.h"} = 1;
+        $headerIncludes{"core/svg/properties/SVGStaticListPropertyTearOff.h"} = 1;
     } elsif ($svgNativeType =~ /SVGTransformListPropertyTearOff/) {
         $svgListPropertyType = $svgWrappedNativeType;
-        $headerIncludes{"SVGAnimatedListPropertyTearOff.h"} = 1;
-        $headerIncludes{"SVGTransformListPropertyTearOff.h"} = 1;
+        $headerIncludes{"core/svg/properties/SVGAnimatedListPropertyTearOff.h"} = 1;
+        $headerIncludes{"core/svg/properties/SVGTransformListPropertyTearOff.h"} = 1;
     } elsif ($svgNativeType =~ /SVGPathSegListPropertyTearOff/) {
         $svgListPropertyType = $svgWrappedNativeType;
-        $headerIncludes{"SVGPathSegListPropertyTearOff.h"} = 1;
+        $headerIncludes{"core/svg/properties/SVGPathSegListPropertyTearOff.h"} = 1;
     }
 
     if ($svgPropertyType) {
         $svgPropertyType = "SVGPoint" if $svgPropertyType eq "FloatPoint";
     }
 
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType);
 }
 
 sub GenerateHeader
@@ skipping 17 matching lines @@
         foreach (@{$interface->parents}) {
             my $parent = $_;
             $headerIncludes{"V8${parent}.h"} = 1;
         }
     }
 
     # - Add default header template
     AddToHeader(GenerateHeaderContentHeader($interface));
 
     $headerIncludes{"wtf/text/StringHash.h"} = 1;
-    $headerIncludes{"WrapperTypeInfo.h"} = 1;
-    $headerIncludes{"V8Binding.h"} = 1;
-    $headerIncludes{"V8DOMWrapper.h"} = 1;
+    $headerIncludes{"bindings/v8/WrapperTypeInfo.h"} = 1;
+    $headerIncludes{"bindings/v8/V8Binding.h"} = 1;
+    $headerIncludes{"bindings/v8/V8DOMWrapper.h"} = 1;
     $headerIncludes{"wtf/HashMap.h"} = 1;
     $headerIncludes{"v8.h"} = 1;
 
     my $headerClassInclude = GetHeaderClassInclude($interfaceName);
     $headerIncludes{$headerClassInclude} = 1 if $headerClassInclude ne "";
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     foreach my $headerInclude (sort keys(%headerIncludes)) {
         if ($headerInclude =~ /wtf|v8\.h/) {
@@ skipping 353 matching lines @@
 
     my @customInternalFields = ();
     # Event listeners on DOM nodes are explicitly supported in the GC controller.
     if (!$codeGenerator->InheritsInterface($interface, "Node") &&
         $codeGenerator->InheritsExtendedAttribute($interface, "EventTarget")) {
         push(@customInternalFields, "eventListenerCacheIndex");
     }
     return @customInternalFields;
 }
 
+sub mapInterfaceToIncludePath
+{
+    my $interface = shift;
+
+    return idlToPath($interface);
+}
+
 sub GetHeaderClassInclude
 {
     my $v8InterfaceName = shift;
     if ($v8InterfaceName =~ /SVGPathSeg/) {
         $v8InterfaceName =~ s/Abs|Rel//;
     }
     return "wtf/${v8InterfaceName}.h" if $codeGenerator->IsTypedArrayType($v8InterfaceName);
     return "" if ($codeGenerator->SkipIncludeHeader($v8InterfaceName));
-    return "${v8InterfaceName}.h";
+    my $interfacepath = mapInterfaceToIncludePath($v8InterfaceName);
+    return "${interfacepath}${v8InterfaceName}.h";
 }
 
 sub GenerateHeaderCustomInternalFieldIndices
 {
     my $interface = shift;
     my @customInternalFields = GetInternalFields($interface);
     my $customFieldCounter = 0;
     foreach my $customInternalField (@customInternalFields) {
         AddToHeader(<<END);
     static const int ${customInternalField} = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
@@ skipping 164 matching lines @@
     my $v8InterfaceName = "V8" . $interfaceName;
     my $funcName = $function->signature->name;
 
     my $signature = "v8::Signature::New(V8PerIsolateData::from(info.GetIsolate())->rawTemplate(&" . $v8InterfaceName . "::info, currentWorldType))";
     if ($function->signature->extendedAttributes->{"DoNotCheckSignature"}) {
         $signature = "v8::Local<v8::Signature>()";
     }
 
     my $newTemplateParams = "${interfaceName}V8Internal::${funcName}MethodCallback, v8Undefined(), $signature";
 
-    AddToImplIncludes("Frame.h");
+    AddToImplIncludes("core/page/Frame.h");
     AddToImplContentInternals(<<END);
 static v8::Handle<v8::Value> ${funcName}AttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static const char* privateTemplateUniqueKey = "${funcName}PrivateTemplate";
     WrapperWorldType currentWorldType = worldType(info.GetIsolate());
     V8PerIsolateData* data = V8PerIsolateData::from(info.GetIsolate());
     v8::Persistent<v8::FunctionTemplate> privateTemplate = data->privateTemplate(currentWorldType, &privateTemplateUniqueKey, $newTemplateParams);
 
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8InterfaceName}::GetTemplate(info.GetIsolate(), currentWorldType));
@@ skipping 242 matching lines @@
     }
 
     # Generate security checks if necessary
     if ($attribute->signature->extendedAttributes->{"CheckSecurityForNode"}) {
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(BindingState::instance(), imp->" . $attribute->signature->name . "()))\n        return v8::Handle<v8::Value>(v8Null(info.GetIsolate()));\n\n";
     }
 
     my $useExceptions = 1 if $attribute->signature->extendedAttributes->{"GetterRaisesException"};
     my $isNullable = $attribute->signature->isNullable;
     if ($useExceptions) {
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($isNullable) {
         $code .= "    bool isNull = false;\n";
     }
 
     my $returnType = $attribute->signature->type;
     my $getterString;
 
     if ($getterStringUsesImp) {
         my ($functionName, @arguments) = $codeGenerator->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("${implementedBy}.h");
+            my $implementedByPath = idlToPath($implementedBy);
+            AddToImplIncludes("${implementedByPath}${implementedBy}.h");
             unshift(@arguments, "imp") if !$attribute->isStatic;
             $functionName = "${implementedBy}::${functionName}";
         } elsif ($attribute->isStatic) {
             $functionName = "${interfaceName}::${functionName}";
         } else {
             $functionName = "imp->${functionName}";
         }
         my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 0);
         $code .= $subCode;
         unshift(@arguments, @$arg);
@@ skipping 45 matching lines @@
     if ((!$codeGenerator->InheritsInterface($interface, "Node") && $attrName ne "self" && IsWrapperType($returnType) && (IsReadonly($attribute) || $attribute->signature->extendedAttributes->{"Replaceable"} || $attrName eq "location")
          && $returnType ne "EventTarget" && $returnType ne "SerializedScriptValue" && $returnType ne "DOMWindow"
          && $returnType ne "MessagePortArray"
          && $returnType !~ /SVG/ && $returnType !~ /HTML/ && !IsDOMNodeType($returnType))
         || $attribute->signature->extendedAttributes->{"CacheAttributeForGC"}) {
 
         my $arrayType = $codeGenerator->GetArrayType($returnType);
         if ($arrayType) {
             if (!$codeGenerator->SkipIncludeHeader($arrayType)) {
                 AddToImplIncludes("V8$arrayType.h");
-                AddToImplIncludes("$arrayType.h");
+                AddToImplIncludes("bindings/v8/$arrayType.h");
             }
             $code .= "    return v8Array(${getterString}, info.GetIsolate());\n";
             $code .= "}\n\n";
             AddToImplContentInternals($code);
             return;
         }
 
         AddIncludesForType($returnType);
         # Check for a wrapper in the wrapper cache. If there is one, we know that a hidden reference has already
         # been created. If we don't find a wrapper, we create both a wrapper and a hidden reference.
@@ skipping 15 matching lines @@
         return;
     }
 
     if (($codeGenerator->IsSVGAnimatedType($interfaceName) or $interfaceName eq "SVGViewSpec") and $codeGenerator->IsSVGTypeNeedingTearOff($attrType)) {
         AddToImplIncludes("V8$attrType.h");
         my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($attrType);
         # Convert from abstract SVGProperty to real type, so the right toJS() method can be invoked.
         $code .= "    return toV8Fast$forMainWorldSuffix(static_cast<$svgNativeType*>($expression), info, imp);\n";
     } elsif ($codeGenerator->IsSVGTypeNeedingTearOff($attrType) and not $interfaceName =~ /List$/) {
         AddToImplIncludes("V8$attrType.h");
-        AddToImplIncludes("SVGPropertyTearOff.h");
+        AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $tearOffType = $codeGenerator->GetSVGTypeNeedingTearOff($attrType);
         my $wrappedValue;
         if ($codeGenerator->IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->signature->extendedAttributes->{"Immutable"}) {
             my $getter = $expression;
             $getter =~ s/imp->//;
             $getter =~ s/\(\)//;
 
             my $updateMethod = "&${interfaceName}::update" . $codeGenerator->WK_ucfirst($getter);
 
             my $selfIsTearOffType = $codeGenerator->IsSVGTypeNeedingTearOff($interfaceName);
             if ($selfIsTearOffType) {
-                AddToImplIncludes("SVGStaticPropertyWithParentTearOff.h");
+                AddToImplIncludes("core/svg/properties/SVGStaticPropertyWithParentTearOff.h");
                 $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyWithParentTearOff<$interfaceName, /;
 
                 if ($expression =~ /matrix/ and $interfaceName eq "SVGTransform") {
                     # SVGTransform offers a matrix() method for internal usage that returns an AffineTransform
                     # and a svgMatrix() method returning a SVGMatrix, used for the bindings.
                     $expression =~ s/matrix/svgMatrix/;
                 }
 
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create(wrapper, $expression, $updateMethod))";
             } else {
@@ skipping 62 matching lines @@
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
 
     my $code = "";
     $code .= <<END;
 static void ${interfaceName}ReplaceableAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
 END
     if ($interface->extendedAttributes->{"CheckSecurity"}) {
-        AddToImplIncludes("Frame.h");
+        AddToImplIncludes("core/page/Frame.h");
         $code .= <<END;
     ${interfaceName}* imp = V8${interfaceName}::toNative(info.Holder());
     if (!BindingSecurity::shouldAllowAccessToFrame(BindingState::instance(), imp->frame()))
         return;
 END
     }
 
     $code .= <<END;
     info.This()->ForceSet(name, value);
 }
 
 END
     AddToImplContentInternals($code);
 }
 
 sub GenerateCustomElementInvocationScopeIfNeeded
 {
     my $code = "";
     my $ext = shift;
 
     if ($ext->{"DeliverCustomElementCallbacks"}) {
         if ($ext->{"Reflect"}) {
             die "IDL error: [Reflect] and [DeliverCustomElementCallbacks] cannot coexist yet";
         }
 
-        AddToImplIncludes("CustomElementRegistry.h", "CUSTOM_ELEMENTS");
+        AddToImplIncludes("core/dom/CustomElementRegistry.h", "CUSTOM_ELEMENTS");
         $code .= <<END;
 #if ENABLE(CUSTOM_ELEMENTS)
     CustomElementRegistry::CallbackDeliveryScope deliveryScope;
 #endif
 END
     }
     return $code;
 }
 
 sub GenerateNormalAttrSetterCallback
@@ skipping 65 matching lines @@
     }
 
     my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($interfaceName);
     if ($svgNativeType) {
         my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List$/) {
             $code .= <<END;
     $svgNativeType* imp = ${v8InterfaceName}::toNative(info.Holder());
 END
         } else {
-            AddToImplIncludes("ExceptionCode.h");
+            AddToImplIncludes("core/dom/ExceptionCode.h");
             $code .= "    $svgNativeType* wrapper = ${v8InterfaceName}::toNative(info.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        setDOMException(NO_MODIFICATION_ALLOWED_ERR, info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif ($attrExt->{"OnProto"}) {
         $code .= <<END;
@@ skipping 63 matching lines @@
     my $returnType = $attribute->signature->type;
     if ($codeGenerator->IsRefPtrType($returnType) && !$codeGenerator->GetArrayType($returnType)) {
         $expression = "WTF::getPtr(" . $expression . ")";
     }
 
     $code .= GenerateCustomElementInvocationScopeIfNeeded($attribute->signature->extendedAttributes);
 
     my $useExceptions = 1 if $attribute->signature->extendedAttributes->{"SetterRaisesException"};
 
     if ($useExceptions) {
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($interfaceName eq "SVGNumber") {
         $code .= "    *imp = $expression;\n";
     } else {
         if ($attribute->signature->type eq "EventListener") {
             my $implSetterFunctionName = $codeGenerator->WK_ucfirst($attrName);
-            AddToImplIncludes("V8AbstractEventListener.h");
+            AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
             if (!$codeGenerator->InheritsInterface($interface, "Node")) {
                 $code .= "    transferHiddenDependency(info.Holder(), imp->$attrName(), value, ${v8InterfaceName}::eventListenerCacheIndex, info.GetIsolate());\n";
             }
-            AddToImplIncludes("V8EventListenerList.h");
+            AddToImplIncludes("bindings/v8/V8EventListenerList.h");
             if ($interfaceName eq "WorkerContext" and $attribute->signature->name eq "onerror") {
-                AddToImplIncludes("V8WorkerContextErrorHandler.h");
+                AddToImplIncludes("bindings/v8/V8WorkerContextErrorHandler.h");
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8WorkerContextErrorHandler>(value, true)";
             } elsif ($interfaceName eq "DOMWindow" and $attribute->signature->name eq "onerror") {
-                AddToImplIncludes("V8WindowErrorHandler.h");
+                AddToImplIncludes("bindings/v8/V8WindowErrorHandler.h");
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8WindowErrorHandler>(value, true)";
             } else {
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::getEventListener(value, true, ListenerFindOrCreate)";
             }
             $code .= ", ec" if $useExceptions;
             $code .= ");\n";
         } else {
             my ($functionName, @arguments) = $codeGenerator->SetterExpression(\%implIncludes, $interfaceName, $attribute);
             push(@arguments, $expression);
             push(@arguments, "ec") if $useExceptions;
             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
-                AddToImplIncludes("${implementedBy}.h");
+                my $implementedByPath = idlToPath($implementedBy);
+                AddToImplIncludes("$implementedByPath${implementedBy}.h");
                 unshift(@arguments, "imp") if !$attribute->isStatic;
                 $functionName = "${implementedBy}::${functionName}";
             } elsif ($attribute->isStatic) {
                 $functionName = "${interfaceName}::${functionName}";
             } else {
                 $functionName = "imp->${functionName}";
             }
             my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 1);
             $code .= $subCode;
             unshift(@arguments, @$arg);
@@ skipping 228 matching lines @@
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         AddToImplContentInternals($code);
         return;
     }
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($name eq "set" and $interface->extendedAttributes->{"TypedArray"}) {
-        AddToImplIncludes("V8ArrayBufferViewCustom.h");
+        AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
     return setWebGLArrayHelper<$interfaceName, ${v8InterfaceName}>(args);
 }
 
 END
         AddToImplContentInternals($code);
         return;
     }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     if ($svgNativeType) {
         my $nativeClassName = GetNativeType($interfaceName); 
         if ($interfaceName =~ /List$/) {
             $code .= "    $nativeClassName imp = ${v8InterfaceName}::toNative(args.Holder());\n";
         } else {
-            AddToImplIncludes("ExceptionCode.h");
+            AddToImplIncludes("core/dom/ExceptionCode.h");
             $code .= "    $nativeClassName wrapper = ${v8InterfaceName}::toNative(args.Holder());\n";
             $code .= "    if (wrapper->isReadOnly())\n";
             $code .= "        return setDOMException(NO_MODIFICATION_ALLOWED_ERR, args.GetIsolate());\n";
             my $svgWrappedNativeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($interfaceName);
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif (!$function->isStatic) {
         $code .= <<END;
     ${interfaceName}* imp = ${v8InterfaceName}::toNative(args.Holder());
 END
     }
 
     $code .= GenerateCustomElementInvocationScopeIfNeeded($funcExt);
 
     # Check domain security if needed
     if ($interface->extendedAttributes->{"CheckSecurity"} && !$function->signature->extendedAttributes->{"DoNotCheckSecurity"}) {
         # We have not find real use cases yet.
-        AddToImplIncludes("Frame.h");
+        AddToImplIncludes("core/page/Frame.h");
         $code .= <<END;
     if (!BindingSecurity::shouldAllowAccessToFrame(BindingState::instance(), imp->frame()))
         return v8Undefined();
 END
     }
 
     my $raisesExceptions = $function->signature->extendedAttributes->{"RaisesException"};
     if (!$raisesExceptions) {
         foreach my $parameter (@{$function->parameters}) {
             if ((!$parameter->extendedAttributes->{"Callback"} and TypeCanFailConversion($parameter)) or $parameter->extendedAttributes->{"IsIndex"}) {
                 $raisesExceptions = 1;
             }
         }
     }
 
     if ($raisesExceptions) {
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
         $code .= "    {\n";
         # The brace here is needed to prevent the ensuing 'goto fail's from jumping past constructors
         # of objects (like Strings) declared later, causing compile errors. The block scope ends
         # right before the label 'fail:'.
     }
 
     if ($function->signature->extendedAttributes->{"CheckSecurityForNode"}) {
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(BindingState::instance(), imp->" . $function->signature->name . "(ec)))\n";
         $code .= "        return v8::Handle<v8::Value>(v8Null(args.GetIsolate()));\n";
@@ skipping 34 matching lines @@
         $code .= $indent . "ScriptState& state = *currentState;\n";
         push(@callWithArgs, "&state");
     }
     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptExecutionContext")) {
         $code .= $indent . "ScriptExecutionContext* scriptContext = getScriptExecutionContext();\n";
         push(@callWithArgs, "scriptContext");
     }
     if ($function and $codeGenerator->ExtendedAttributeContains($callWith, "ScriptArguments")) {
         $code .= $indent . "RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, " . @{$function->parameters} . "));\n";
         push(@callWithArgs, "scriptArguments.release()");
-        AddToImplIncludes("ScriptArguments.h");
-        AddToImplIncludes("ScriptCallStackFactory.h");
+        AddToImplIncludes("core/inspector/ScriptArguments.h");
+        AddToImplIncludes("bindings/v8/ScriptCallStackFactory.h");
     }
     return ([@callWithArgs], $code);
 }
 
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
 
     my $numMandatoryParams = 0;
@@ skipping 59 matching lines @@
             $parameterDefaultPolicy = "DefaultIsNullString";
         }
 
         my $parameterName = $parameter->name;
         if (GetIndexOf($parameterName, @paramTransferListNames) != -1) {
             $replacements{$parameterName} = "messagePortArray" . ucfirst($parameterName);
             $paramIndex++;
             next;
         }
 
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         if ($parameter->extendedAttributes->{"Callback"}) {
             my $v8InterfaceName = "V8" . $parameter->type;
             AddToImplIncludes("$v8InterfaceName.h");
             if ($parameter->isOptional) {
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
                 $parameterCheckString .= "    if (args.Length() > $paramIndex && !args[$paramIndex]->IsNull() && !args[$paramIndex]->IsUndefined()) {\n";
                 $parameterCheckString .= "        if (!args[$paramIndex]->IsFunction())\n";
                 $parameterCheckString .= "            return throwTypeError(0, args.GetIsolate());\n";
                 $parameterCheckString .= "        $parameterName = ${v8InterfaceName}::create(args[$paramIndex], getScriptExecutionContext());\n";
                 $parameterCheckString .= "    }\n";
             } else {
                 $parameterCheckString .= "    if (args.Length() <= $paramIndex || !args[$paramIndex]->IsFunction())\n";
                 $parameterCheckString .= "        return throwTypeError(0, args.GetIsolate());\n";
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ${v8InterfaceName}::create(args[$paramIndex], getScriptExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
                 my $nativeValue = "${parameterName}NativeValue";
                 my $paramType = $parameter->type;
                 $parameterCheckString .= "    $paramType $parameterName = 0;\n";
                 $parameterCheckString .= "    V8TRYCATCH(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$paramType>($nativeValue);\n";
         } elsif ($parameter->type eq "SerializedScriptValue") {
-            AddToImplIncludes("SerializedScriptValue.h");
+            AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
             my $useTransferList = 0;
             my $transferListName = "";
             my $TransferListName = "";
             if ($parameter->extendedAttributes->{"TransferList"}) {
                 $transferListName = $parameter->extendedAttributes->{"TransferList"};
                 push(@paramTransferListNames, $transferListName);
 
                 my @allParameterNames = ();
                 foreach my $parameter (@{$function->parameters}) {
                     push(@allParameterNames, $parameter->name);
                 }
                 my $transferListIndex = GetIndexOf($transferListName, @allParameterNames);
                 if ($transferListIndex == -1) {
                     die "IDL error: TransferList refers to a nonexistent argument";
                 }
 
                 AddToImplIncludes("wtf/ArrayBuffer.h");
-                AddToImplIncludes("MessagePort.h");
+                AddToImplIncludes("core/dom/MessagePort.h");
                 $TransferListName = ucfirst($transferListName);
                 $parameterCheckString .= "    MessagePortArray messagePortArray$TransferListName;\n";
                 $parameterCheckString .= "    ArrayBufferArray arrayBufferArray$TransferListName;\n";
                 $parameterCheckString .= "    if (args.Length() > $transferListIndex) {\n";
                 $parameterCheckString .= "        if (!extractTransferables(args[$transferListIndex], messagePortArray$TransferListName, arrayBufferArray$TransferListName, args.GetIsolate()))\n";
                 $parameterCheckString .= "            return throwTypeError(\"Could not extract transferables\", args.GetIsolate());\n";
                 $parameterCheckString .= "    }\n";
                 $useTransferList = 1;
             }
             $parameterCheckString .= "    bool ${parameterName}DidThrow = false;\n";
@@ skipping 141 matching lines @@
     $code .= <<END;
 static v8::Handle<v8::Value> constructor${overloadedIndexString}(const v8::Arguments& args)
 {
 END
 
     if ($function->{overloadedIndex} == 0) {
         $code .= GenerateArgumentsCountCheck($function, $interface);
     }
 
     if ($raisesExceptions) {
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "\n";
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     # FIXME: Currently [Constructor(...)] does not yet support optional arguments without [Default=...]
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interfaceName, "");
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"CallWith"} && $interface->extendedAttributes->{"CallWith"} eq "ScriptExecutionContext") {
         push(@beforeArgumentList, "context");
@@ skipping 101 matching lines @@
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 sub GenerateEventConstructor
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
 
-    AddToImplIncludes("Dictionary.h");
+    AddToImplIncludes("bindings/v8/Dictionary.h");
     AddToImplContentInternals(<<END);
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
     ${interfaceName}Init eventInit;
     if (args.Length() >= 2) {
         V8TRYCATCH(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
@@ skipping 38 matching lines @@
 END
     AddToImplContent($code);
 }
 
 sub GenerateTypedArrayConstructor
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $viewType = GetTypeNameOfExternalTypedArray($interface);
     my $type = $interface->extendedAttributes->{"TypedArray"};
-    AddToImplIncludes("V8ArrayBufferViewCustom.h");
+    AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
 
     AddToImplContentInternals(<<END);
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
     return constructWebGLArray<$interfaceName, V8${interfaceName}, $type>(args, &V8${interfaceName}::info, $viewType);
 }
 
 END
 }
 
@@ skipping 24 matching lines @@
     my $toActiveDOMObject = "0";
     if ($codeGenerator->InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         $toActiveDOMObject = "${v8InterfaceName}::toActiveDOMObject";
     }
 
     my $toEventTarget = "0";
     if ($codeGenerator->InheritsExtendedAttribute($interface, "EventTarget")) {
         $toEventTarget = "${v8InterfaceName}::toEventTarget";
     }
 
-    AddToImplIncludes("Frame.h");
+    AddToImplIncludes("core/page/Frame.h");
     AddToImplContent(<<END);
 WrapperTypeInfo ${v8InterfaceName}Constructor::info = { ${v8InterfaceName}Constructor::GetTemplate, ${v8InterfaceName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8InterfaceName}::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
 
 END
 
     my $code = "";
     $code .= <<END;
 static v8::Handle<v8::Value> ${v8InterfaceName}ConstructorCallback(const v8::Arguments& args)
 {
     ${maybeObserveFeature}
 END
     $code .= GenerateConstructorHeader();
     AddToImplIncludes("V8Document.h");
     $code .= <<END;
     Document* document = currentDocument(BindingState::instance());
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${interfaceName} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
     toV8(document, args.Holder(), args.GetIsolate());
 
 END
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($raisesExceptions) {
-        AddToImplIncludes("ExceptionCode.h");
+        AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "\n";
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interfaceName);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "document");
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
@@ skipping 141 matching lines @@
     my $data = "0 /* no data */";
 
     # Constructor
     if ($attribute->signature->type =~ /Constructor$/) {
         my $constructorType = $attribute->signature->type;
         $constructorType =~ s/Constructor$//;
         # $constructorType ~= /Constructor$/ indicates that it is NamedConstructor.
         # We do not generate the header file for NamedConstructor of class XXXX,
         # since we generate the NamedConstructor declaration into the header file of class XXXX.
         if ($constructorType !~ /Constructor$/ || $attribute->signature->extendedAttributes->{"CustomConstructor"}) {
-            AddToImplIncludes("V8${constructorType}.h", $attribute->signature->extendedAttributes->{"Conditional"});
+            my $includepath = "";
+            if ($constructorType eq "HTMLImageElementConstructor") {
+                $includepath = "bindings/v8/custom/";
+            }
+            AddToImplIncludes("${includepath}V8${constructorType}.h", $attribute->signature->extendedAttributes->{"Conditional"});
         }
         $data = "&V8${constructorType}::info";
         $getter = "${interfaceName}V8Internal::${interfaceName}ConstructorGetter";
         $setter = "${interfaceName}V8Internal::${interfaceName}ReplaceableAttrSetterCallback";
         $getterForMainWorld = "0";
         $setterForMainWorld = "0";
     } else {
         # Default Getter and Setter
         $getter = "${interfaceName}V8Internal::${attrName}AttrGetterCallback";
         $setter = "${interfaceName}V8Internal::${attrName}AttrSetterCallback";
@@ skipping 164 matching lines @@
     # FIXME: Find a way to not have to special-case HTMLOptionsCollection.
     if ($interfaceName eq "HTMLOptionsCollection") {
         $hasEnumerator = 1;
         $hasIndexedGetter = 1;
     }
 
     if (!$hasIndexedGetter) {
         return "";
     }
 
-    AddToImplIncludes("V8Collection.h");
+    AddToImplIncludes("bindings/v8/V8Collection.h");
 
     if (!$indexer) {
         $indexer = $codeGenerator->FindSuperMethod($interface, "item");
     }
 
     my $indexerType = $indexer ? $indexer->type : 0;
 
     if ($indexerType && !$hasCustomIndexedSetter) {
         $hasEnumerator = 1;
     }
@@ skipping 67 matching lines @@
 
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     if (!$namedPropertyGetter) {
         $namedPropertyGetter = $codeGenerator->FindSuperMethod($interface, "namedItem");
     }
 
     if ($interface->extendedAttributes->{"NamedGetter"}) {
         die "$interfaceName: [NamedGetter] but no namedItem() method." if (!$namedPropertyGetter);
-        AddToImplIncludes("V8Collection.h");
+        AddToImplIncludes("bindings/v8/V8Collection.h");
         my $type = $namedPropertyGetter->type;
         $subCode .= <<END;
     desc->InstanceTemplate()->SetNamedPropertyHandler(${v8InterfaceName}::namedPropertyGetter, 0, 0, 0, 0);
 END
 
         my $code .= <<END;
 v8::Handle<v8::Value> ${v8InterfaceName}::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
         return v8Undefined();
@@ skipping 90 matching lines @@
     my $visibleInterfaceName = $codeGenerator->GetVisibleInterfaceName($interface);
     my $v8InterfaceName = "V8$interfaceName";
     my $nativeType = GetNativeTypeForConversions($interface);
     my $vtableNameGnu = GetGnuVTableNameForInterface($interface);
     my $vtableRefGnu = GetGnuVTableRefForInterface($interface);
     my $vtableRefWin = GetWinVTableRefForInterface($interface);
 
     # - Add default header template
     push(@implContentHeader, GenerateImplementationContentHeader($interface));
 
-    AddToImplIncludes("BindingState.h");
-    AddToImplIncludes("ContextFeatures.h");
-    AddToImplIncludes("RuntimeEnabledFeatures.h");
-    AddToImplIncludes("V8Binding.h");
-    AddToImplIncludes("V8DOMWrapper.h");
+    AddToImplIncludes("bindings/v8/BindingState.h");
+    AddToImplIncludes("core/dom/ContextFeatures.h");
+    AddToImplIncludes("core/page/RuntimeEnabledFeatures.h");
+    AddToImplIncludes("bindings/v8/V8Binding.h");
+    AddToImplIncludes("bindings/v8/V8DOMWrapper.h");
 
     AddIncludesForType($interfaceName);
 
     my $toActiveDOMObject = $codeGenerator->InheritsExtendedAttribute($interface, "ActiveDOMObject") ? "${v8InterfaceName}::toActiveDOMObject" : "0";
     my $toEventTarget = $codeGenerator->InheritsExtendedAttribute($interface, "EventTarget") ? "${v8InterfaceName}::toEventTarget" : "0";
     my $rootForGC = NeedsCustomOpaqueRootForGC($interface) ? "${v8InterfaceName}::opaqueRootForGC" : "0";
 
     # Find the super descriptor.
     my $parentClass = "";
     my $parentClassTemplate = "";
@@ skipping 95 matching lines @@
                 $hasConstructors = 1;
             }
             next;
         }
 
         if ($attrType eq "EventListener" && $interfaceName eq "DOMWindow") {
             $attrExt->{"OnProto"} = 1;
         }
 
         if ($attrType eq "SerializedScriptValue") {
-            AddToImplIncludes("SerializedScriptValue.h");
+            AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         }
 
         GenerateNormalAttrGetter($attribute, $interface, "");
         GenerateNormalAttrGetterCallback($attribute, $interface, "");
         if ($attrExt->{"PerWorldBindings"}) {
             GenerateNormalAttrGetter($attribute, $interface, "ForMainWorld");
             GenerateNormalAttrGetterCallback($attribute, $interface, "ForMainWorld");
         }
         if (!HasCustomSetter($attrExt) && $attrExt->{"Replaceable"}) {
             $hasReplaceable = 1;
@@ skipping 172 matching lines @@
         $has_constants = 1;
         $code .= "static const V8DOMConfiguration::BatchedConstant ${v8InterfaceName}Consts[] = {\n";
     }
     foreach my $constant (@{$interface->constants}) {
         my $name = $constant->name;
         my $value = $constant->value;
         my $attrExt = $constant->extendedAttributes;
         my $conditional = $attrExt->{"Conditional"};
         my $implementedBy = $attrExt->{"ImplementedBy"};
         if ($implementedBy) {
-            AddToImplIncludes("${implementedBy}.h");
+            my $implementedByPath = idlToPath($implementedBy);
+            AddToImplIncludes("${implementedByPath}${implementedBy}.h");
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
             push(@constantsEnabledAtRuntime, $constant);
         } else {
             if ($conditional) {
                 my $conditionalString = $codeGenerator->GenerateConditionalStringFromAttributeValue($conditional);
                 $code .= "#if ${conditionalString}\n";
             }
             # 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.
@@ skipping 414 matching lines @@
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
 
     # - Add default header template
     AddToHeader(GenerateHeaderContentHeader($interface));
 
     my @unsortedIncludes = ();
-    push(@unsortedIncludes, "#include \"ActiveDOMCallback.h\"");
-    push(@unsortedIncludes, "#include \"DOMWrapperWorld.h\"");
-    push(@unsortedIncludes, "#include \"$interfaceName.h\"");
-    push(@unsortedIncludes, "#include \"ScopedPersistent.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/ActiveDOMCallback.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/DOMWrapperWorld.h\"");
+    my $interfacePath = idlToPath($interfaceName);
+    push(@unsortedIncludes, "#include \"$interfacePath$interfaceName.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/ScopedPersistent.h\"");
     push(@unsortedIncludes, "#include <v8.h>");
     push(@unsortedIncludes, "#include <wtf/Forward.h>");
     AddToHeader(join("\n", sort @unsortedIncludes));
     
     AddToHeader("\n\nnamespace WebCore {\n\n");
     AddToHeader("class ScriptExecutionContext;\n\n");
     AddToHeader("class $v8InterfaceName : public $interfaceName, public ActiveDOMCallback {\n");
 
     AddToHeader(<<END);
 public:
@@ skipping 53 matching lines @@
 sub GenerateCallbackImplementation
 {
     my $object = shift;
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     # - Add default header template
     push(@implContentHeader, GenerateImplementationContentHeader($interface));
 
-    AddToImplIncludes("ScriptExecutionContext.h");
-    AddToImplIncludes("V8Binding.h");
-    AddToImplIncludes("V8Callback.h");
+    AddToImplIncludes("core/dom/ScriptExecutionContext.h");
+    AddToImplIncludes("bindings/v8/V8Binding.h");
+    AddToImplIncludes("bindings/v8/V8Callback.h");
 
     AddToImplContent("#include <wtf/Assertions.h>\n\n");
     AddToImplContent("namespace WebCore {\n\n");
 
     AddToImplContent(<<END);
 ${v8InterfaceName}::${v8InterfaceName}(v8::Handle<v8::Object> callback, ScriptExecutionContext* context)
     : ActiveDOMCallback(context)
     , m_callback(callback)
     , m_world(DOMWrapperWorld::current())
 {
@@ skipping 90 matching lines @@
 {
     my $interface = shift;
     my $v8InterfaceName = shift;
     my $nativeType = shift;
     my $interfaceName = $interface->name;
 
     if ($interface->extendedAttributes->{"NoWrapperCache"} || $interface->extendedAttributes->{"SuppressToJSObject"}) {
         return;
     }
 
-    AddToImplIncludes("Frame.h");
+    AddToImplIncludes("core/page/Frame.h");
     AddToImplIncludes("ScriptController.h");
 
     my $createWrapperArgumentType = GetPassRefPtrType($nativeType);
     my $baseType = BaseInterfaceName($interface);
 
     my $code = "";
     $code .= <<END;
 
 v8::Handle<v8::Object> ${v8InterfaceName}::createWrapper(${createWrapperArgumentType} impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
@@ skipping 205 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("${implementedBy}.h");
+        my $implementedByPath = idlToPath($implementedBy);
+        AddToImplIncludes("${implementedByPath}${implementedBy}.h");
         unshift(@arguments, "imp") if !$function->isStatic;
         $functionName = "${implementedBy}::${name}";
     } elsif ($function->isStatic) {
         $functionName = "${interfaceName}::${name}";
     } else {
         $functionName = "imp->${name}";
     }
 
     my $callWith = $function->signature->extendedAttributes->{"CallWith"};
     my ($callWithArgs, $subCode) = GenerateCallWith($callWith, $indent, 0, $function);
@@ skipping 56 matching lines @@
     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptState")) {
         $code .= $indent . "if (state.hadException()) {\n";
         $code .= $indent . "    v8::Local<v8::Value> exception = state.exception();\n";
         $code .= $indent . "    state.clearException();\n";
         $code .= $indent . "    return throwError(exception, args.GetIsolate());\n";
         $code .= $indent . "}\n";
     }
 
     if ($isSVGTearOffType) {
         AddToImplIncludes("V8$returnType.h");
-        AddToImplIncludes("SVGPropertyTearOff.h");
+        AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $svgNativeType = $codeGenerator->GetSVGTypeNeedingTearOff($returnType);
         # FIXME: Update for all ScriptWrappables.
         if (IsDOMNodeType($interfaceName)) {
             $code .= $indent . "return toV8Fast${forMainWorldSuffix}(WTF::getPtr(${svgNativeType}::create($return)), args, imp);\n";
         } else {
             $code .= $indent . "return toV8${forMainWorldSuffix}(WTF::getPtr(${svgNativeType}::create($return)), args.Holder(), args.GetIsolate());\n";
         }
         return $code;
     }
 
@@ skipping 107 matching lines @@
 
     # Callbacks use raw pointers, so pass isParameter = 1
     return GetNativeType($type, 1);
 }
 
 sub TypeCanFailConversion
 {
     my $signature = shift;
     my $type = $signature->type;
 
-    AddToImplIncludes("ExceptionCode.h") if $type eq "Attr";
+    AddToImplIncludes("core/dom/ExceptionCode.h") if $type eq "Attr";
     return 1 if $type eq "Attr";
     return 0;
 }
 
 sub JSValueToNative
 {
     my $signature = shift;
     my $value = shift;
     my $getIsolate = shift;
 
@@ skipping 21 matching lines @@
 
     if ($type eq "DOMString") {
         return $value;
     }
 
     if ($codeGenerator->IsEnumType($type)) {
         return $value;
     }
 
     if ($type eq "SerializedScriptValue") {
-        AddToImplIncludes("SerializedScriptValue.h");
+        AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         return "SerializedScriptValue::create($value, $getIsolate)";
     }
 
     if ($type eq "Dictionary") {
-        AddToImplIncludes("Dictionary.h");
+        AddToImplIncludes("bindings/v8/Dictionary.h");
         return "Dictionary($value, $getIsolate)";
     }
 
     if ($type eq "any") {
-        AddToImplIncludes("ScriptValue.h");
+        AddToImplIncludes("bindings/v8/ScriptValue.h");
         return "ScriptValue($value)";
     }
 
     if ($type eq "NodeFilter") {
         return "toNodeFilter($value)";
     }
 
     if ($type eq "MediaQueryListListener") {
-        AddToImplIncludes("MediaQueryListListener.h");
+        AddToImplIncludes("core/css/MediaQueryListListener.h");
         return "MediaQueryListListener::create(" . $value . ")";
     }
 
     if ($type eq "EventTarget") {
         return "V8DOMWrapper::isDOMWrapper($value) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast($value))->toEventTarget(v8::Handle<v8::Object>::Cast($value)) : 0";
     }
 
     if ($type eq "XPathNSResolver") {
         return "toXPathNSResolver($value, $getIsolate)";
     }
@@ skipping 13 matching lines @@
     AddIncludesForType($type);
 
     AddToImplIncludes("V8${type}.h");
     return "V8${type}::HasInstance($value, $getIsolate, worldType($getIsolate)) ? V8${type}::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
 }
 
 sub GetV8HeaderName
 {
     my $type = shift;
     return "V8Event.h" if $type eq "DOMTimeStamp";
-    return "EventListener.h" if $type eq "EventListener";
-    return "SerializedScriptValue.h" if $type eq "SerializedScriptValue";
-    return "ScriptValue.h" if $type eq "any";
+    return "core/dom/EventListener.h" if $type eq "EventListener";
+    return "bindings/v8/SerializedScriptValue.h" if $type eq "SerializedScriptValue";
+    return "bindings/v8/ScriptValue.h" if $type eq "any";
+    return "bindings/v8/V8GCController.h" if $type eq "GCController";
     return "V8${type}.h";
 }
 
 sub CreateCustomSignature
 {
     my $function = shift;
     my $count = @{$function->parameters};
     my $name = $function->signature->name;
     my $code = "    const int ${name}Argc = ${count};\n" .
       "    v8::Handle<v8::FunctionTemplate> ${name}Argv[${name}Argc] = { ";
     my $first = 1;
     foreach my $parameter (@{$function->parameters}) {
         if ($first) { $first = 0; }
         else { $code .= ", "; }
         if (IsWrapperType($parameter->type)) {
             if ($parameter->type eq "XPathNSResolver") {
                 # Special case for XPathNSResolver.  All other browsers accepts a callable,
                 # so, even though it's against IDL, accept objects here.
                 $code .= "v8::Handle<v8::FunctionTemplate>()";
             } else {
                 my $type = $parameter->type;
 
                 my $arrayType = $codeGenerator->GetArrayType($type);
                 my $sequenceType = $codeGenerator->GetSequenceType($type);
                 my $arrayOrSequenceType = $arrayType || $sequenceType;
 
                 if ($arrayOrSequenceType) {
                     if ($arrayType eq "DOMString") {
                         AddToImplIncludes("V8DOMStringList.h");
-                        AddToImplIncludes("DOMStringList.h");
+                        AddToImplIncludes("core/dom/DOMStringList.h");
 
                     } elsif ($codeGenerator->IsRefPtrType($arrayOrSequenceType)) {
                         AddToImplIncludes(GetV8HeaderName($arrayOrSequenceType));
                         AddToImplIncludes("${arrayOrSequenceType}.h");
                     } else {
                         $code .= "v8::Handle<v8::FunctionTemplate>()";
                         next;
                     }
                 } else {
                     AddToImplIncludes(GetV8HeaderName($type));
@@ skipping 180 matching lines @@
         return "v8String($value, $getIsolate$returnHandleTypeArg)";
     }
 
     my $arrayType = $codeGenerator->GetArrayType($type);
     my $sequenceType = $codeGenerator->GetSequenceType($type);
     my $arrayOrSequenceType = $arrayType || $sequenceType;
 
     if ($arrayOrSequenceType) {
         if ($arrayType eq "DOMString") {
             AddToImplIncludes("V8DOMStringList.h");
-            AddToImplIncludes("DOMStringList.h");
+            AddToImplIncludes("core/dom/DOMStringList.h");
 
         } elsif ($codeGenerator->IsRefPtrType($arrayOrSequenceType)) {
             AddToImplIncludes(GetV8HeaderName($arrayOrSequenceType));
-            AddToImplIncludes("${arrayOrSequenceType}.h");
+            my $includepath = idlToPath($arrayOrSequenceType); # This is not an arraytype (always?). It's things like ScriptProfileNode, MediaStreamTream, MediaStreamTream, MediaStream.
+            AddToImplIncludes("${includepath}${arrayOrSequenceType}.h");
         }
         return "v8Array($value, $getIsolate)";
     }
 
     AddIncludesForType($type);
 
     if (IsDOMNodeType($type) || $type eq "EventTarget") {
       if ($getScriptWrappable) {
           return "toV8Fast${forMainWorldSuffix}($value$getHolderContainerArg$getScriptWrappableArg)";
       }
       return "toV8($value, $getCreationContext, $getIsolate)";
     }
 
     if ($type eq "EventListener") {
-        AddToImplIncludes("V8AbstractEventListener.h");
+        AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
         return "${value} ? v8::Handle<v8::Value>(static_cast<V8AbstractEventListener*>(${value})->getListenerObject(imp->scriptExecutionContext())) : v8::Handle<v8::Value>(v8Null($getIsolate))";
     }
 
     if ($type eq "SerializedScriptValue") {
         AddToImplIncludes("$type.h");
         return "$value ? $value->deserialize() : v8::Handle<v8::Value>(v8Null($getIsolate))";
     }
 
     AddToImplIncludes("wtf/RefCounted.h");
     AddToImplIncludes("wtf/RefPtr.h");
@@ skipping 111 matching lines @@
 
 sub GetPassRefPtrType
 {
     my $v8InterfaceName = shift;
 
     my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
     return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
 }
 
 1;