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;
 
         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 357 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;