Rename DOMPath IDL interface to Path to match the specification

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 127 matching lines @@
 #       Class
 #         ClassPublic
 #         ClassPrivate
 my %header;
 
 # Implementation code structure:
 # Root                    ... Copyright
 #   Conditional           ... #if FEATURE ... #endif  (to be removed soon)
 #     Includes
 #     NameSpaceWebCore
-#     NameSpaceInternal   ... namespace ${interfaceName}V8Internal in case of non-callback
+#     NameSpaceInternal   ... namespace ${implClassName}V8Internal in case of non-callback
 my %implementation;
 
 my %primitiveTypeHash = ( "boolean" => 1,
                           "void" => 1,
                           "Date" => 1,
                           "short" => 1,
                           "long" => 1,
                           "long long" => 1,
                           "unsigned short" => 1,
                           "unsigned long" => 1,
@@ skipping 99 matching lines @@
         };
         find($wanted, @directories);
     }
 
     return $idlFiles->{$interfaceName};
 }
 
 sub HeaderFileForInterface
 {
     my $interfaceName = shift;
+    my $implClassName = shift || $interfaceName;
 
     my $idlFilename = IDLFileForInterface($interfaceName)
         or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
 
-    $idlFilename = "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
-    $idlFilename =~ s/idl$/h/;
-    return $idlFilename;
+    my $idlRelPath= "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
+    return dirname($idlRelPath) . "/" . $implClassName . ".h";
 }
 
 sub ParseInterface
 {
     my $interfaceName = shift;
 
     return undef if $interfaceName eq 'Object';
 
     if (exists $cachedInterfaces->{$interfaceName}) {
         return $cachedInterfaces->{$interfaceName};
@@ skipping 18 matching lines @@
 
     die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 sub GenerateInterface
 {
     my $object = shift;
     my $interface = shift;
 
     %enumTypeHash = map { $_->name => $_->values } @{$idlDocument->enumerations};
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8" . $interface->name;
-    my $defineName = $v8InterfaceName . "_h";
-    my $internalNamespace = "${interfaceName}V8Internal";
+    my $v8ClassName = GetV8ClassName($interface);
+    my $defineName = $v8ClassName . "_h";
+    my $internalNamespace = GetImplClassName($interface) . "V8Internal";
 
     my $conditionalString = GenerateConditionalString($interface);
     my $conditionalIf = "";
     my $conditionalEndif = "";
     if ($conditionalString) {
         $conditionalIf = "#if ${conditionalString}";
         $conditionalEndif = "#endif // ${conditionalString}";
     }
 
     $header{root} = new Block("ROOT", "", "");
@@ skipping 33 matching lines @@
     $implementation{root}->add($implementation{conditional});
     $implementation{conditional}->add($implementation{includes});
     $implementation{conditional}->add($implementation{nameSpaceWebCore});
     if (!$interface->isCallback) {
         $implementation{nameSpaceWebCore}->add($implementation{nameSpaceInternal});
     }
 
     # - Add default header template
     $implementation{root}->addHeader($headerTemplate);
     $implementation{root}->addHeader("\n#include \"config.h\"");
-    $implementation{includes}->add("#include \"${v8InterfaceName}.h\"\n\n");
+    $implementation{includes}->add("#include \"${v8ClassName}.h\"\n\n");
 
     # Start actual generation
     if ($interface->isCallback) {
         $object->GenerateCallbackHeader($interface);
         $object->GenerateCallbackImplementation($interface);
     } else {
         $object->GenerateHeader($interface);
         $object->GenerateImplementation($interface);
     }
 }
@@ skipping 21 matching lines @@
 }
 
 sub AddToHeaderIncludes
 {
     my $header = shift;
     $headerIncludeFiles{$header} = 1;
 }
 
 sub AddInterfaceToImplIncludes
 {
-    my $interface = shift;
-    my $include = HeaderFileForInterface($interface);
+    my $interfaceName = shift;
+
+    my $include = HeaderFileForInterface($interfaceName);
 
     AddToImplIncludes($include);
 }
 
 sub AddIncludesForType
 {
     my $type = shift;
 
     # When we're finished with the one-file-per-class
     # reorganization, we won't need these special cases.
@@ skipping 57 matching lines @@
 
 sub GetCustomIsReachable
 {
     my $interface = shift;
     return $interface->extendedAttributes->{"CustomIsReachable"};
 }
 
 sub GenerateOpaqueRootForGC
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     if (GetCustomIsReachable($interface)) {
         return;
     }
 
     my $code = <<END;
-void* V8${interfaceName}::opaqueRootForGC(void* object, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
+void* ${v8ClassName}::opaqueRootForGC(void* object, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
 {
     ASSERT(!wrapper.IsIndependent(isolate));
-    ${interfaceName}* impl = static_cast<${interfaceName}*>(object);
+    ${implClassName}* impl = static_cast<${implClassName}*>(object);
 END
     if (GetGenerateIsReachable($interface) eq  "ImplDocument" ||
         GetGenerateIsReachable($interface) eq  "ImplElementRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerNodeRoot") {
 
         AddToImplIncludes("bindings/v8/V8GCController.h");
 
         my $methodName;
         $methodName = "document" if (GetGenerateIsReachable($interface) eq "ImplDocument");
@@ skipping 99 matching lines @@
 
     return 0;
 }
 
 sub GenerateHeader
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     # Copy contents of parent interfaces except the first parent.
     my @parents;
     AddMethodsConstantsAndAttributesFromParentInterfaces($interface, \@parents, 1);
     LinkOverloadedFunctions($interface);
 
     # Ensure the IsDOMNodeType function is in sync.
     die("IsDOMNodeType is out of date with respect to $interfaceName") if IsDOMNodeType($interfaceName) != InheritsInterface($interface, "Node");
 
-    my $hasDependentLifetime = $interface->extendedAttributes->{"DependentLifetime"} || InheritsExtendedAttribute($interface, "ActiveDOMObject") || GetGenerateIsReachable($interface) || $v8InterfaceName =~ /SVG/;
+    my $hasDependentLifetime = $interface->extendedAttributes->{"DependentLifetime"} || InheritsExtendedAttribute($interface, "ActiveDOMObject") || GetGenerateIsReachable($interface) || $v8ClassName =~ /SVG/;
     if (!$hasDependentLifetime) {
         foreach (@{$interface->parents}) {
             my $parent = $_;
             AddToHeaderIncludes("V8${parent}.h");
         }
     }
 
     AddToHeaderIncludes("bindings/v8/WrapperTypeInfo.h");
     AddToHeaderIncludes("bindings/v8/V8Binding.h");
     AddToHeaderIncludes("bindings/v8/V8DOMWrapper.h");
     AddToHeaderIncludes("v8.h");
     AddToHeaderIncludes("wtf/HashMap.h");
     AddToHeaderIncludes("wtf/text/StringHash.h");
 
-    my $headerClassInclude = GetHeaderClassInclude($interfaceName);
+    my $headerClassInclude = GetHeaderClassInclude($interfaceName, $implClassName);
     AddToHeaderIncludes($headerClassInclude) if $headerClassInclude;
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     foreach my $headerInclude (sort keys(%headerIncludeFiles)) {
         $header{includes}->add("#include \"${headerInclude}\"\n") unless $headerInclude =~ /v8\.h/;
     }
     $header{includes}->add("#include \<v8.h\>\n") if $headerIncludeFiles{"v8.h"};
 
     $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGPropertyTearOff;\n") if $svgPropertyType;
@@ skipping 13 matching lines @@
         $header{nameSpaceWebCore}->addHeader(<<END);
 
 class V8${nativeType}Constructor {
 public:
     static v8::Persistent<v8::FunctionTemplate> GetTemplate(v8::Isolate*, WrapperWorldType);
     static WrapperTypeInfo info;
 };
 END
     }
 
-    $header{class}->addHeader("class $v8InterfaceName {");
+    $header{class}->addHeader("class $v8ClassName {");
     $header{class}->addFooter("};");
 
     my $code = "";
     $code .= "    static const bool hasDependentLifetime = ";
     if ($hasDependentLifetime) {
         $code .= "true;\n";
     } elsif (@{$interface->parents}) {
         # Even if this type doesn't have the [DependentLifetime] attribute its parents may.
         # Let the compiler statically determine this for us.
         my $separator = "";
@@ skipping 163 matching lines @@
     friend v8::Handle<v8::Object> wrap(${nativeType}*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
     static v8::Handle<v8::Object> createWrapper(${createWrapperArgumentType}, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 END
     }
 
     $header{nameSpaceWebCore}->add(<<END);
 
 template<>
 class WrapperTypeTraits<${nativeType} > {
 public:
-    static WrapperTypeInfo* info() { return &${v8InterfaceName}::info; }
+    static WrapperTypeInfo* info() { return &${v8ClassName}::info; }
 };
 
 END
 
     my $customWrap = $interface->extendedAttributes->{"CustomToV8"};
     if ($noToV8) {
         die "Can't suppress toV8 for subclass\n" if @parents;
     } elsif ($noWrap) {
         die "Must have custom toV8\n" if !$customWrap;
         $header{nameSpaceWebCore}->add(<<END);
 class ${nativeType};
 v8::Handle<v8::Value> toV8(${nativeType}*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 v8::Handle<v8::Value> toV8ForMainWorld(${nativeType}*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8Fast(${nativeType}* impl, const HolderContainer& container, Wrappable*)
 {
     return toV8(impl, container.Holder(), container.GetIsolate());
 }
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8FastForMainWorld(${nativeType}* impl, const HolderContainer& container, Wrappable*)
 {
     return toV8ForMainWorld(impl, container.Holder(), container.GetIsolate());
 }
 END
     } else {
 
-        my $createWrapperCall = $customWrap ? "${v8InterfaceName}::wrap" : "${v8InterfaceName}::createWrapper";
+        my $createWrapperCall = $customWrap ? "${v8ClassName}::wrap" : "${v8ClassName}::createWrapper";
         my $returningWrapper = $interface->extendedAttributes->{"WrapAsFunction"} ? "V8DOMWrapper::toFunction(wrapper)" : "wrapper";
         my $returningCreatedWrapperOpening = $interface->extendedAttributes->{"WrapAsFunction"} ? "V8DOMWrapper::toFunction(" : "";
-        my $returningCreatedWrapperClosing = $interface->extendedAttributes->{"WrapAsFunction"} ? ", \"${interfaceName}\", isolate)" : "";
+        my $returningCreatedWrapperClosing = $interface->extendedAttributes->{"WrapAsFunction"} ? ", \"${implClassName}\", isolate)" : "";
 
         if ($customWrap) {
             $header{nameSpaceWebCore}->add(<<END);
 
 v8::Handle<v8::Object> wrap(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 END
         } else {
             $header{nameSpaceWebCore}->add(<<END);
 
 inline v8::Handle<v8::Object> wrap(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
     ASSERT(DOMDataStore::getWrapper(impl, isolate).IsEmpty());
     if (ScriptWrappable::wrapperCanBeStoredInObject(impl)) {
         const WrapperTypeInfo* actualInfo = ScriptWrappable::getTypeInfoFromObject(impl);
         // Might be a XXXConstructor::info instead of an XXX::info. These will both have
         // the same object de-ref functions, though, so use that as the basis of the check.
-        RELEASE_ASSERT(actualInfo->derefObjectFunction == ${v8InterfaceName}::info.derefObjectFunction);
+        RELEASE_ASSERT(actualInfo->derefObjectFunction == ${v8ClassName}::info.derefObjectFunction);
     }
     return ${returningCreatedWrapperOpening}$createWrapperCall(impl, creationContext, isolate)${returningCreatedWrapperClosing};
 }
 END
         }
 
         $header{nameSpaceWebCore}->add(<<END);
 
 inline v8::Handle<v8::Value> toV8(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
@@ skipping 57 matching lines @@
 }
 
 inline v8::Handle<v8::Value> toV8(PassRefPtr< ${nativeType} > impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl.get(), creationContext, isolate);
 }
 
 END
 
     if (IsConstructorTemplate($interface, "Event")) {
-        $header{nameSpaceWebCore}->add("bool fill${interfaceName}Init(${interfaceName}Init&, const Dictionary&);\n\n");
+        $header{nameSpaceWebCore}->add("bool fill${implClassName}Init(${implClassName}Init&, const Dictionary&);\n\n");
     }
 }
 
 sub GetInternalFields
 {
     my $interface = shift;
 
     my @customInternalFields = ();
     # Event listeners on DOM nodes are explicitly supported in the GC controller.
     if (!InheritsInterface($interface, "Node") &&
         InheritsExtendedAttribute($interface, "EventTarget")) {
         push(@customInternalFields, "eventListenerCacheIndex");
     }
     return @customInternalFields;
 }
 
 sub GetHeaderClassInclude
 {
-    my $v8InterfaceName = shift;
-    if ($v8InterfaceName =~ /SVGPathSeg/) {
-        $v8InterfaceName =~ s/Abs|Rel//;
-        return "core/svg/${v8InterfaceName}.h";
+    my $interfaceName = shift;
+    my $implClassName = shift;
+
+    if ($interfaceName =~ /SVGPathSeg/) {
+        $interfaceName =~ s/Abs|Rel//;
+        return "core/svg/${interfaceName}.h";
     }
-    return "wtf/${v8InterfaceName}.h" if IsTypedArrayType($v8InterfaceName);
-    return "" if (SkipIncludeHeader($v8InterfaceName));
-    return HeaderFileForInterface($v8InterfaceName);
+    return "wtf/${interfaceName}.h" if IsTypedArrayType($interfaceName);
+    return "" if (SkipIncludeHeader($interfaceName));
+    return HeaderFileForInterface($interfaceName, $implClassName);
 }
 
 sub GenerateHeaderCustomInternalFieldIndices
 {
     my $interface = shift;
     my @customInternalFields = GetInternalFields($interface);
     my $customFieldCounter = 0;
     foreach my $customInternalField (@customInternalFields) {
         $header{classPublic}->add(<<END);
     static const int ${customInternalField} = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
 END
         $customFieldCounter++;
     }
     $header{classPublic}->add(<<END);
     static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
 END
 }
 
 sub GenerateHeaderNamedAndIndexedPropertyAccessors
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
     my $hasIndexedGetter = GetIndexedGetterFunction($interface) || $interface->extendedAttributes->{"CustomIndexedGetter"};
     my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
     my $hasCustomNamedGetter = GetNamedGetterFunction($interface) || $interface->extendedAttributes->{"CustomNamedGetter"};
     my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
     my $hasCustomDeleters = $interface->extendedAttributes->{"CustomDeleteProperty"};
     my $hasCustomEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
 
     if ($hasIndexedGetter) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t, const v8::AccessorInfo&);
@@ skipping 99 matching lines @@
     return $attrExt->{"Custom"};
 }
 
 sub IsReadonly
 {
     my $attribute = shift;
     my $attrExt = $attribute->signature->extendedAttributes;
     return $attribute->isReadOnly && !$attrExt->{"Replaceable"};
 }
 
+sub GetV8ClassName
+{
+    my $interface = shift;
+    return "V8" . $interface->name;
+}
+
+sub GetImplClassName
+{
+    my $interface = shift;
+    return $interface->extendedAttributes->{"ImplementedAs"} || $interface->name;
+}
+
 sub GenerateDomainSafeFunctionGetter
 {
     my $function = shift;
-    my $interfaceName = shift;
+    my $interface = shift;
 
-    my $v8InterfaceName = "V8" . $interfaceName;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $funcName = $function->signature->name;
 
     my $functionLength = GetFunctionLength($function);
-    my $signature = "v8::Signature::New(V8PerIsolateData::from(info.GetIsolate())->rawTemplate(&" . $v8InterfaceName . "::info, currentWorldType))";
+    my $signature = "v8::Signature::New(V8PerIsolateData::from(info.GetIsolate())->rawTemplate(&" . $v8ClassName . "::info, currentWorldType))";
     if ($function->signature->extendedAttributes->{"DoNotCheckSignature"}) {
         $signature = "v8::Local<v8::Signature>()";
     }
 
-    my $newTemplateParams = "${interfaceName}V8Internal::${funcName}MethodCallback, v8Undefined(), $signature";
+    my $newTemplateParams = "${implClassName}V8Internal::${funcName}MethodCallback, v8Undefined(), $signature";
 
     AddToImplIncludes("core/page/Frame.h");
     AddToImplIncludes("bindings/v8/BindingSecurity.h");
     $implementation{nameSpaceInternal}->add(<<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, $functionLength);
 
-    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8InterfaceName}::GetTemplate(info.GetIsolate(), currentWorldType));
+    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), currentWorldType));
     if (holder.IsEmpty()) {
         // can only reach here by 'object.__proto__.func', and it should passed
         // domain security check already
         return privateTemplate->GetFunction();
     }
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(holder);
+    ${implClassName}* imp = ${v8ClassName}::toNative(holder);
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame(), DoNotReportSecurityError)) {
         static const char* sharedTemplateUniqueKey = "${funcName}SharedTemplate";
         v8::Persistent<v8::FunctionTemplate> sharedTemplate = data->privateTemplate(currentWorldType, &sharedTemplateUniqueKey, $newTemplateParams, $functionLength);
         return sharedTemplate->GetFunction();
     }
 
     v8::Local<v8::Value> hiddenValue = info.This()->GetHiddenValue(name);
     if (!hiddenValue.IsEmpty())
         return hiddenValue;
 
     return privateTemplate->GetFunction();
 }
 
 END
     $implementation{nameSpaceInternal}->add(<<END);
 static v8::Handle<v8::Value> ${funcName}AttrGetterCallback(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    return ${interfaceName}V8Internal::${funcName}AttrGetter(name, info);
+    return ${implClassName}V8Internal::${funcName}AttrGetter(name, info);
 }
 
 END
 }
 
 sub GenerateDomainSafeFunctionSetter
 {
-    my $interfaceName = shift;
-    my $v8InterfaceName = "V8" . $interfaceName;
+    my $interface = shift;
+
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("bindings/v8/BindingSecurity.h");
     $implementation{nameSpaceInternal}->add(<<END);
-static void ${interfaceName}DomainSafeFunctionSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+static void ${implClassName}DomainSafeFunctionSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
-    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8InterfaceName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
+    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(holder);
+    ${implClassName}* imp = ${v8ClassName}::toNative(holder);
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame()))
         return;
 
     info.This()->SetHiddenValue(name, value);
 }
 
 END
 }
 
 sub GenerateConstructorGetter
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
 
     $implementation{nameSpaceInternal}->add(<<END);
-static v8::Handle<v8::Value> ${interfaceName}ConstructorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+static v8::Handle<v8::Value> ${implClassName}ConstructorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     v8::Handle<v8::Value> data = info.Data();
     ASSERT(data->IsExternal());
     V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
     if (!perContextData)
         return v8Undefined();
     return perContextData->constructorForType(WrapperTypeInfo::unwrap(data));
 }
 END
 }
@@ skipping 62 matching lines @@
 
     return $code;
 }
 
 sub GenerateNormalAttrGetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->signature->extendedAttributes;
     my $attrName = $attribute->signature->name;
 
     my $conditionalString = GenerateConditionalString($attribute->signature);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static v8::Handle<v8::Value> ${attrName}AttrGetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::AccessorInfo& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Getter")) {
         $code .= GenerateActivityLogging("Getter", $interface, "${attrName}");
     }
     if (HasCustomGetter($attrExt)) {
-        $code .= "    return ${v8InterfaceName}::${attrName}AttrGetterCustom(name, info);\n";
+        $code .= "    return ${v8ClassName}::${attrName}AttrGetterCustom(name, info);\n";
     } else {
-        $code .= "    return ${interfaceName}V8Internal::${attrName}AttrGetter${forMainWorldSuffix}(name, info);\n";
+        $code .= "    return ${implClassName}V8Internal::${attrName}AttrGetter${forMainWorldSuffix}(name, info);\n";
     }
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
 
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateNormalAttrGetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->signature->extendedAttributes;
     my $attrName = $attribute->signature->name;
     my $attrType = $attribute->signature->type;
 
     if (HasCustomGetter($attrExt)) {
         return;
     }
 
     AssertNotSequenceType($attrType);
     my $getterStringUsesImp = $interfaceName ne "SVGNumber";
     my $nativeType = GetNativeTypeFromSignature($attribute->signature, -1);
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
 
     my $conditionalString = GenerateConditionalString($attribute->signature);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static v8::Handle<v8::Value> ${attrName}AttrGetter${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
 END
     if ($svgNativeType) {
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List/) {
             $code .= <<END;
-    $svgNativeType* imp = ${v8InterfaceName}::toNative(info.Holder());
+    $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
             $code .= <<END;
-    $svgNativeType* wrapper = ${v8InterfaceName}::toNative(info.Holder());
+    $svgNativeType* wrapper = ${v8ClassName}::toNative(info.Holder());
     $svgWrappedNativeType& impInstance = wrapper->propertyReference();
 END
             if ($getterStringUsesImp) {
                 $code .= <<END;
     $svgWrappedNativeType* imp = &impInstance;
 END
             }
         }
     } elsif ($attrExt->{"OnProto"} || $attrExt->{"Unforgeable"}) {
         if ($interfaceName eq "DOMWindow") {
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.Holder();
 END
         } else {
             # perform lookup first
             $code .= <<END;
-    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8InterfaceName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
+    v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return v8Undefined();
 END
         }
         $code .= <<END;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(holder);
+    ${implClassName}* imp = ${v8ClassName}::toNative(holder);
 END
     } else {
         my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
         my $url = $attribute->signature->extendedAttributes->{"URL"};
         if ($getterStringUsesImp && $reflect && !$url && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute getter:
             my ($functionName, @arguments) = GetterExpression(\%implIncludes, $interfaceName, $attribute);
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    return v8String(imp->${functionName}(" . join(", ", @arguments) . "), info.GetIsolate(), ReturnUnsafeHandle);\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
         if ($attribute->signature->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
             $code .= <<END;
     v8::Handle<v8::String> propertyName = v8::String::NewSymbol("${attrName}");
     v8::Handle<v8::Value> value = info.Holder()->GetHiddenValue(propertyName);
     if (!value.IsEmpty())
         return value;
 END
         }
         if (!$attribute->isStatic) {
             $code .= <<END;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(info.Holder());
+    ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
     # Generate security checks if necessary
     if ($attribute->signature->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . $attribute->signature->name . "()))\n        return v8::Handle<v8::Value>(v8Null(info.GetIsolate()));\n\n";
     }
 
@@ skipping 14 matching lines @@
     if ($getterStringUsesImp) {
         my ($functionName, @arguments) = GetterExpression(\%implIncludes, $interfaceName, $attribute);
         push(@arguments, "isNull") if $isNullable;
         push(@arguments, "ec") if $useExceptions;
         if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
             my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
             AddInterfaceToImplIncludes($implementedBy);
             unshift(@arguments, "imp") if !$attribute->isStatic;
             $functionName = "${implementedBy}::${functionName}";
         } elsif ($attribute->isStatic) {
-            $functionName = "${interfaceName}::${functionName}";
+            $functionName = "${implClassName}::${functionName}";
         } else {
             $functionName = "imp->${functionName}";
         }
         my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 0);
         $code .= $subCode;
         unshift(@arguments, @$arg);
         $getterString = "${functionName}(" . join(", ", @arguments) . ")";
     } else {
         $getterString = "impInstance";
     }
@@ skipping 78 matching lines @@
     } elsif (IsSVGTypeNeedingTearOff($attrType) and not $interfaceName =~ /List$/) {
         AddToImplIncludes("V8$attrType.h");
         AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $tearOffType = GetSVGTypeNeedingTearOff($attrType);
         my $wrappedValue;
         if (IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->signature->extendedAttributes->{"Immutable"}) {
             my $getter = $expression;
             $getter =~ s/imp->//;
             $getter =~ s/\(\)//;
 
-            my $updateMethod = "&${interfaceName}::update" . FirstLetterToUpperCase($getter);
+            my $updateMethod = "&${implClassName}::update" . FirstLetterToUpperCase($getter);
 
             my $selfIsTearOffType = IsSVGTypeNeedingTearOff($interfaceName);
             if ($selfIsTearOffType) {
                 AddToImplIncludes("core/svg/properties/SVGStaticPropertyWithParentTearOff.h");
-                $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyWithParentTearOff<$interfaceName, /;
+                $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyWithParentTearOff<$implClassName, /;
 
                 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 {
                 AddToImplIncludes("core/svg/properties/SVGStaticPropertyTearOff.h");
-                $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyTearOff<$interfaceName, /;
+                $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyTearOff<$implClassName, /;
 
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create(imp, $expression, $updateMethod))";
             }
         } elsif ($tearOffType =~ /SVGStaticListPropertyTearOff/) {
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create(imp, $expression))";
         } elsif ($tearOffType =~ /SVG(Point|PathSeg)List/) {
                 $wrappedValue = "WTF::getPtr($expression)";
         } else {
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create($expression))";
         }
@@ skipping 60 matching lines @@
     return 0 if $returnType eq "MessagePortArray";
     return 0 if $returnType =~ /SVG/;
     return 0 if $returnType =~ /HTML/;
 
     return 1;
 }
 
 sub GenerateReplaceableAttrSetterCallback
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
 
     my $code = "";
-    $code .= "static void ${interfaceName}ReplaceableAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)\n";
+    $code .= "static void ${implClassName}ReplaceableAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
     if (HasActivityLogging("", $interface->extendedAttributes, "Setter")) {
          die "IDL error: ActivityLog attribute cannot exist on a ReplacableAttrSetterCallback";
     }
-    $code .= "    return ${interfaceName}V8Internal::${interfaceName}ReplaceableAttrSetter(name, value, info);\n";
+    $code .= "    return ${implClassName}V8Internal::${implClassName}ReplaceableAttrSetter(name, value, info);\n";
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateReplaceableAttrSetter
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     my $code = "";
     $code .= <<END;
-static void ${interfaceName}ReplaceableAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+static void ${implClassName}ReplaceableAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
 END
     if ($interface->extendedAttributes->{"CheckSecurity"}) {
         AddToImplIncludes("core/page/Frame.h");
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= <<END;
-    ${interfaceName}* imp = V8${interfaceName}::toNative(info.Holder());
+    ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame()))
         return;
 END
     }
 
     $code .= <<END;
     info.This()->ForceSet(name, value);
 }
 
 END
@@ skipping 17 matching lines @@
     }
     return $code;
 }
 
 sub GenerateNormalAttrSetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->signature->extendedAttributes;
     my $attrName = $attribute->signature->name;
 
     my $conditionalString = GenerateConditionalString($attribute->signature);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static void ${attrName}AttrSetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Setter")) {
         $code .= GenerateActivityLogging("Setter", $interface, "${attrName}");
     }
     if (HasCustomSetter($attrExt)) {
-        $code .= "    ${v8InterfaceName}::${attrName}AttrSetterCustom(name, value, info);\n";
+        $code .= "    ${v8ClassName}::${attrName}AttrSetterCustom(name, value, info);\n";
     } else {
-        $code .= "    ${interfaceName}V8Internal::${attrName}AttrSetter${forMainWorldSuffix}(name, value, info);\n";
+        $code .= "    ${implClassName}V8Internal::${attrName}AttrSetter${forMainWorldSuffix}(name, value, info);\n";
     }
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateNormalAttrSetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $attrName = $attribute->signature->name;
     my $attrExt = $attribute->signature->extendedAttributes;
     my $attrType = $attribute->signature->type;
 
     if (HasCustomSetter($attrExt)) {
         return;
     }
 
     my $conditionalString = GenerateConditionalString($attribute->signature);
     my $code = "";
@@ skipping 14 matching lines @@
             $code .= "        return;\n";
             $code .= "    }\n";
         }
     }
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
     if ($svgNativeType) {
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List$/) {
             $code .= <<END;
-    $svgNativeType* imp = ${v8InterfaceName}::toNative(info.Holder());
+    $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
             AddToImplIncludes("core/dom/ExceptionCode.h");
-            $code .= "    $svgNativeType* wrapper = ${v8InterfaceName}::toNative(info.Holder());\n";
+            $code .= "    $svgNativeType* wrapper = ${v8ClassName}::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;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(info.Holder());
+    ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
     } else {
         my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
         if ($reflect && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute setter:
             my $contentAttributeName = $reflect eq "VALUE_IS_MISSING" ? lc $attrName : $reflect;
             my $namespace = NamespaceForAttributeName($interfaceName, $contentAttributeName);
             AddToImplIncludes("${namespace}.h");
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, stringResource, value);\n";
             $code .= "    imp->setAttribute(${namespace}::${contentAttributeName}Attr, stringResource);\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
 
         if (!$attribute->isStatic) {
             $code .= <<END;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(info.Holder());
+    ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
     my $nativeType = GetNativeTypeFromSignature($attribute->signature, 0);
     if ($attribute->signature->type eq "EventListener") {
         if ($interface->name eq "DOMWindow") {
             $code .= "    if (!imp->document())\n";
             $code .= "        return;\n";
         }
@@ skipping 42 matching lines @@
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($interfaceName eq "SVGNumber") {
         $code .= "    *imp = $expression;\n";
     } else {
         if ($attribute->signature->type eq "EventListener") {
             my $implSetterFunctionName = FirstLetterToUpperCase($attrName);
             AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
             if (!InheritsInterface($interface, "Node")) {
-                $code .= "    transferHiddenDependency(info.Holder(), imp->$attrName(), value, ${v8InterfaceName}::eventListenerCacheIndex, info.GetIsolate());\n";
+                $code .= "    transferHiddenDependency(info.Holder(), imp->$attrName(), value, ${v8ClassName}::eventListenerCacheIndex, info.GetIsolate());\n";
             }
             AddToImplIncludes("bindings/v8/V8EventListenerList.h");
             if ($interfaceName eq "WorkerContext" and $attribute->signature->name eq "onerror") {
                 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("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) = SetterExpression(\%implIncludes, $interfaceName, $attribute);
             push(@arguments, $expression);
             push(@arguments, "ec") if $useExceptions;
             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
                 AddInterfaceToImplIncludes($implementedBy);
                 unshift(@arguments, "imp") if !$attribute->isStatic;
                 $functionName = "${implementedBy}::${functionName}";
             } elsif ($attribute->isStatic) {
-                $functionName = "${interfaceName}::${functionName}";
+                $functionName = "${implClassName}::${functionName}";
             } else {
                 $functionName = "imp->${functionName}";
             }
             my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 1);
             $code .= $subCode;
             unshift(@arguments, @$arg);
             $code .= "    ${functionName}(" . join(", ", @arguments) . ");\n";
         }
     }
 
@@ skipping 113 matching lines @@
         push(@orExpression, GenerateParametersCheckExpression($numParameters, $function));
     }
     return ($numMandatoryParams, join(" || ", @orExpression));
 }
 
 sub GenerateOverloadedFunction
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
-    my $interfaceName = $interface->name;
 
     # Generate code for choosing the correct overload to call. Overloads are
     # chosen based on the total number of arguments passed and the type of
     # values passed in non-primitive argument slots. When more than a single
     # overload is applicable, precedence is given according to the order of
     # declaration in the IDL.
 
     my $name = $function->signature->name;
 
     my $conditionalString = GenerateConditionalString($function->signature);
@@ skipping 25 matching lines @@
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateFunctionCallback
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $name = $function->signature->name;
 
     if ($name eq "") {
         return;
     }
 
     my $conditionalString = GenerateConditionalString($function->signature);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static v8::Handle<v8::Value> ${name}MethodCallback${forMainWorldSuffix}(const v8::Arguments& args)
 {
 END
     $code .= GenerateFeatureObservation($function->signature->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->signature->extendedAttributes->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $function->signature->extendedAttributes, "Access")) {
         $code .= GenerateActivityLogging("Method", $interface, "${name}");
     }
     if (HasCustomMethod($function->signature->extendedAttributes)) {
-        $code .= "    return ${v8InterfaceName}::${name}MethodCustom(args);\n";
+        $code .= "    return ${v8ClassName}::${name}MethodCustom(args);\n";
     } else {
-        $code .= "    return ${interfaceName}V8Internal::${name}Method${forMainWorldSuffix}(args);\n";
+        $code .= "    return ${implClassName}V8Internal::${name}Method${forMainWorldSuffix}(args);\n";
     }
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateFunction
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $name = $function->signature->name;
     my $funcExt = $function->signature->extendedAttributes;
 
     if (HasCustomMethod($funcExt) || $name eq "") {
         return;
     }
 
     if (@{$function->{overloads}} > 1) {
         # Append a number to an overloaded method's name to make it unique:
         $name = $name . $function->{overloadIndex};
     }
 
     my $conditionalString = GenerateConditionalString($function->signature);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= "static v8::Handle<v8::Value> ${name}Method${forMainWorldSuffix}(const v8::Arguments& args)\n";
     $code .= "{\n";
 
     if ($name eq "addEventListener" || $name eq "removeEventListener") {
         my $lookupType = ($name eq "addEventListener") ? "OrCreate" : "Only";
         my $passRefPtrHandling = ($name eq "addEventListener") ? "" : ".get()";
         my $hiddenDependencyAction = ($name eq "addEventListener") ? "create" : "remove";
 
         AddToImplIncludes("bindings/v8/V8EventListenerList.h");
         $code .= <<END;
     RefPtr<EventListener> listener = V8EventListenerList::getEventListener(args[1], false, ListenerFind${lookupType});
     if (listener) {
         V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithNullCheck>, stringResource, args[0]);
-        V8${interfaceName}::toNative(args.Holder())->${name}(stringResource, listener${passRefPtrHandling}, args[2]->BooleanValue());
+        ${v8ClassName}::toNative(args.Holder())->${name}(stringResource, listener${passRefPtrHandling}, args[2]->BooleanValue());
 END
         if (!InheritsInterface($interface, "Node")) {
             $code .= <<END;
-        ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], V8${interfaceName}::eventListenerCacheIndex, args.GetIsolate());
+        ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], ${v8ClassName}::eventListenerCacheIndex, args.GetIsolate());
 END
         }
         $code .= <<END;
     }
     return v8Undefined();
 }
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($name eq "set" and $interface->extendedAttributes->{"TypedArray"}) {
         AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
-    return setWebGLArrayHelper<$interfaceName, ${v8InterfaceName}>(args);
+    return setWebGLArrayHelper<$implClassName, ${v8ClassName}>(args);
 }
 
 END
         $implementation{nameSpaceInternal}->add($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";
+            $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(args.Holder());\n";
         } else {
             AddToImplIncludes("core/dom/ExceptionCode.h");
-            $code .= "    $nativeClassName wrapper = ${v8InterfaceName}::toNative(args.Holder());\n";
+            $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(args.Holder());\n";
             $code .= "    if (wrapper->isReadOnly())\n";
             $code .= "        return setDOMException(NO_MODIFICATION_ALLOWED_ERR, args.GetIsolate());\n";
             my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif (!$function->isStatic) {
         $code .= <<END;
-    ${interfaceName}* imp = ${v8InterfaceName}::toNative(args.Holder());
+    ${implClassName}* imp = ${v8ClassName}::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("core/page/Frame.h");
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
@@ skipping 21 matching lines @@
         # right before the label 'fail:'.
     }
 
     if ($function->signature->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . $function->signature->name . "(ec)))\n";
         $code .= "        return v8::Handle<v8::Value>(v8Null(args.GetIsolate()));\n";
 END
     }
 
-    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interfaceName, $forMainWorldSuffix);
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, $forMainWorldSuffix);
     $code .= $parameterCheckString;
 
     # Build the function call string.
-    $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interfaceName, $forMainWorldSuffix, %replacements);
+    $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interface, $forMainWorldSuffix, %replacements);
 
     if ($raisesExceptions) {
         $code .= "    }\n";
         $code .= "    fail:\n";
         $code .= "    return setDOMException(ec, args.GetIsolate());\n";
     }
 
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
@@ skipping 63 matching lines @@
             return $index;
         }
         $index++;
     }
     return -1;
 }
 
 sub GenerateParametersCheck
 {
     my $function = shift;
-    my $interfaceName = shift;
+    my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $parameterCheckString = "";
     my $paramIndex = 0;
     my %replacements = ();
 
     foreach my $parameter (@{$function->parameters}) {
         my $nativeType = GetNativeTypeFromSignature($parameter, $paramIndex);
 
         # Optional arguments without [Default=...] should generate an early call with fewer arguments.
         # Optional arguments with [Optional=...] should not generate the early call.
         # Optional Dictionary arguments always considered to have default of empty dictionary.
         if ($parameter->isOptional && !$parameter->extendedAttributes->{"Default"} && $nativeType ne "Dictionary" && !IsCallbackInterface($parameter->type)) {
             $parameterCheckString .= "    if (args.Length() <= $paramIndex) {\n";
-            my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interfaceName, $forMainWorldSuffix, %replacements);
+            my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, %replacements);
             $parameterCheckString .= $functionCall;
             $parameterCheckString .= "    }\n";
         }
 
         my $parameterDefaultPolicy = "DefaultIsUndefined";
         my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
         if ($parameter->isOptional and $default eq "NullString") {
             $parameterDefaultPolicy = "DefaultIsNullString";
         }
 
         my $parameterName = $parameter->name;
         AddToImplIncludes("core/dom/ExceptionCode.h");
         if (IsCallbackInterface($parameter->type)) {
-            my $v8InterfaceName = "V8" . $parameter->type;
-            AddToImplIncludes("$v8InterfaceName.h");
+            my $v8ClassName = "V8" . $parameter->type;
+            AddToImplIncludes("$v8ClassName.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 .= "        $parameterName = ${v8ClassName}::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";
+                $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ${v8ClassName}::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("bindings/v8/SerializedScriptValue.h");
@@ skipping 76 matching lines @@
         }
 
         $paramIndex++;
     }
     return ($parameterCheckString, $paramIndex, %replacements);
 }
 
 sub GenerateOverloadedConstructorCallback
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
 
     my $code = "";
     $code .= <<END;
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
 END
     my $leastNumMandatoryParams = 255;
     foreach my $constructor (@{$interface->constructors}) {
         my $name = "constructor" . $constructor->{overloadedIndex};
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($constructor);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
         $code .= "    if ($parametersCheck)\n";
-        $code .= "        return ${interfaceName}V8Internal::${name}(args);\n";
+        $code .= "        return ${implClassName}V8Internal::${name}(args);\n";
     }
     if ($leastNumMandatoryParams >= 1) {
         $code .= "    if (args.Length() < $leastNumMandatoryParams)\n";
         $code .= "        return throwNotEnoughArgumentsError(args.GetIsolate());\n";
     }
     $code .= <<END;
     return throwTypeError(0, args.GetIsolate());
 END
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $overloadedIndexString = "";
     if ($function->{overloadedIndex} > 0) {
         $overloadedIndexString .= $function->{overloadedIndex};
     }
 
     my $raisesExceptions = $function->signature->extendedAttributes->{"RaisesException"};
     if ($interface->extendedAttributes->{"RaisesException"}) {
         $raisesExceptions = 1;
     }
     if (!$raisesExceptions) {
@@ skipping 16 matching lines @@
         $code .= GenerateArgumentsCountCheck($function, $interface);
     }
 
     if ($raisesExceptions) {
         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, "");
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "");
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"CallWith"} && $interface->extendedAttributes->{"CallWith"} eq "ScriptExecutionContext") {
         push(@beforeArgumentList, "context");
         $code .= <<END;
 
     ScriptExecutionContext* context = getScriptExecutionContext();
 END
     }
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
         push(@afterArgumentList, "ec");
     }
 
     my @argumentList;
     my $index = 0;
     foreach my $parameter (@{$function->parameters}) {
         last if $index eq $paramIndex;
         if ($replacements{$parameter->name}) {
             push(@argumentList, $replacements{$parameter->name});
         } else {
             push(@argumentList, $parameter->name);
         }
         $index++;
     }
 
     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
     $code .= "\n";
-    $code .= "    RefPtr<${interfaceName}> impl = ${interfaceName}::create(${argumentString});\n";
+    $code .= "    RefPtr<${implClassName}> impl = ${implClassName}::create(${argumentString});\n";
     $code .= "    v8::Handle<v8::Object> wrapper = args.Holder();\n";
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
         $code .= "    if (ec)\n";
         $code .= "        goto fail;\n";
     }
 
     $code .= <<END;
 
-    V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8${interfaceName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
+    V8DOMWrapper::associateObjectWithWrapper(impl.release(), &${v8ClassName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
     return wrapper;
 END
 
     if ($raisesExceptions) {
         $code .= "    fail:\n";
         $code .= "    return setDOMException(ec, args.GetIsolate());\n";
     }
 
     $code .= "}\n";
     $code .= "\n";
@@ skipping 21 matching lines @@
         }
     }
 
     return $leastConstructorLength;
 }
 
 sub GenerateConstructorCallback
 {
     my $interface = shift;
 
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $code = "";
-    $code .= "v8::Handle<v8::Value> V8${interfaceName}::constructorCallback(const v8::Arguments& args)\n";
+    $code .= "v8::Handle<v8::Value> ${v8ClassName}::constructorCallback(const v8::Arguments& args)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
     $code .= GenerateConstructorHeader();
     if (HasCustomConstructor($interface)) {
-        $code .= "    return V8${interfaceName}::constructorCustom(args);\n";
+        $code .= "    return ${v8ClassName}::constructorCustom(args);\n";
     } else {
-        $code .= "    return ${interfaceName}V8Internal::constructor(args);\n";
+        $code .= "    return ${implClassName}V8Internal::constructor(args);\n";
     }
     $code .= "}\n\n";
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructor
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
 
     if (@{$interface->constructors} == 1) {
         GenerateSingleConstructorCallback($interface, @{$interface->constructors}[0]);
     } else {
         foreach my $constructor (@{$interface->constructors}) {
             GenerateSingleConstructorCallback($interface, $constructor);
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 sub GenerateEventConstructor
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
     $implementation{nameSpaceInternal}->add(<<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;
+    ${implClassName}Init eventInit;
     if (args.Length() >= 2) {
         V8TRYCATCH(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
-        if (!fill${interfaceName}Init(eventInit, options))
+        if (!fill${implClassName}Init(eventInit, options))
             return v8Undefined();
     }
 
-    RefPtr<${interfaceName}> event = ${interfaceName}::create(type, eventInit);
+    RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit);
 
     v8::Handle<v8::Object> wrapper = args.Holder();
-    V8DOMWrapper::associateObjectWithWrapper(event.release(), &V8${interfaceName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
+    V8DOMWrapper::associateObjectWithWrapper(event.release(), &${v8ClassName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
     return wrapper;
 }
 END
 
     my $code = "";
     $code .= <<END;
-bool fill${interfaceName}Init(${interfaceName}Init& eventInit, const Dictionary& options)
+bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
 {
 END
 
     foreach my $interfaceBase (@{$interface->parents}) {
         $code .= <<END;
     if (!fill${interfaceBase}Init(eventInit, options))
         return false;
 
 END
     }
@@ skipping 10 matching lines @@
     return true;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateTypedArrayConstructor
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
+
     my $viewType = GetTypeNameOfExternalTypedArray($interface);
     my $type = $interface->extendedAttributes->{"TypedArray"};
     AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
 
     $implementation{nameSpaceInternal}->add(<<END);
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
-    return constructWebGLArray<$interfaceName, V8${interfaceName}, $type>(args, &V8${interfaceName}::info, $viewType);
+    return constructWebGLArray<$implClassName, ${v8ClassName}, $type>(args, &${v8ClassName}::info, $viewType);
 }
 
 END
 }
 
 sub GenerateNamedConstructor
 {
     my $function = shift;
     my $interface = shift;
 
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $raisesExceptions = $function->signature->extendedAttributes->{"RaisesException"};
     if ($interface->extendedAttributes->{"RaisesException"}) {
         $raisesExceptions = 1;
     }
     if (!$raisesExceptions) {
         foreach my $parameter (@{$function->parameters}) {
             if ((!IsCallbackInterface($parameter->type) and TypeCanFailConversion($parameter)) or $parameter->extendedAttributes->{"IsIndex"}) {
                 $raisesExceptions = 1;
             }
         }
     }
 
     my $maybeObserveFeature = GenerateFeatureObservation($function->signature->extendedAttributes->{"MeasureAs"});
     my $maybeDeprecateFeature = GenerateDeprecationNotification($function->signature->extendedAttributes->{"DeprecateAs"});
 
     my @beforeArgumentList;
     my @afterArgumentList;
 
     my $toActiveDOMObject = "0";
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
-        $toActiveDOMObject = "${v8InterfaceName}::toActiveDOMObject";
+        $toActiveDOMObject = "${v8ClassName}::toActiveDOMObject";
     }
 
     my $toEventTarget = "0";
     if (InheritsExtendedAttribute($interface, "EventTarget")) {
-        $toEventTarget = "${v8InterfaceName}::toEventTarget";
+        $toEventTarget = "${v8ClassName}::toEventTarget";
     }
 
     AddToImplIncludes("core/page/Frame.h");
     $implementation{nameSpaceWebCore}->add(<<END);
-WrapperTypeInfo ${v8InterfaceName}Constructor::info = { ${v8InterfaceName}Constructor::GetTemplate, ${v8InterfaceName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8InterfaceName}::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
+WrapperTypeInfo ${v8ClassName}Constructor::info = { ${v8ClassName}Constructor::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8ClassName}::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
 
 END
 
     my $code = "";
     $code .= <<END;
-static v8::Handle<v8::Value> ${v8InterfaceName}ConstructorCallback(const v8::Arguments& args)
+static v8::Handle<v8::Value> ${v8ClassName}ConstructorCallback(const v8::Arguments& args)
 {
 END
     $code .= $maybeObserveFeature if $maybeObserveFeature;
     $code .= $maybeDeprecateFeature if $maybeDeprecateFeature;
     $code .= GenerateConstructorHeader();
     AddToImplIncludes("V8Document.h");
     $code .= <<END;
     Document* document = currentDocument();
 
-    // Make sure the document is added to the DOM Node map. Otherwise, the ${interfaceName} instance
+    // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} 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("core/dom/ExceptionCode.h");
         $code .= "\n";
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
-    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interfaceName);
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "document");
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
         push(@afterArgumentList, "ec");
     }
 
     my @argumentList;
     my $index = 0;
     foreach my $parameter (@{$function->parameters}) {
         last if $index eq $paramIndex;
         if ($replacements{$parameter->name}) {
             push(@argumentList, $replacements{$parameter->name});
         } else {
             push(@argumentList, $parameter->name);
         }
         $index++;
     }
 
     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
     $code .= "\n";
-    $code .= "    RefPtr<${interfaceName}> impl = ${interfaceName}::createForJSConstructor(${argumentString});\n";
+    $code .= "    RefPtr<${implClassName}> impl = ${implClassName}::createForJSConstructor(${argumentString});\n";
     $code .= "    v8::Handle<v8::Object> wrapper = args.Holder();\n";
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
         $code .= "    if (ec)\n";
         $code .= "        goto fail;\n";
     }
 
     $code .= <<END;
 
-    V8DOMWrapper::associateObjectWithWrapper(impl.release(), &${v8InterfaceName}Constructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
+    V8DOMWrapper::associateObjectWithWrapper(impl.release(), &${v8ClassName}Constructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
     return wrapper;
 END
 
     if ($raisesExceptions) {
         $code .= "    fail:\n";
         $code .= "    return setDOMException(ec, args.GetIsolate());\n";
     }
 
     $code .= "}\n";
     $implementation{nameSpaceWebCore}->add($code);
 
     $code = <<END;
 
-v8::Persistent<v8::FunctionTemplate> ${v8InterfaceName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
+v8::Persistent<v8::FunctionTemplate> ${v8ClassName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
     if (!cachedTemplate.IsEmpty())
         return cachedTemplate;
 
     v8::HandleScope scope;
-    v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(${v8InterfaceName}ConstructorCallback);
+    v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(${v8ClassName}ConstructorCallback);
 
     v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
-    instance->SetInternalFieldCount(${v8InterfaceName}::internalFieldCount);
-    result->SetClassName(v8::String::NewSymbol("${interfaceName}"));
-    result->Inherit(${v8InterfaceName}::GetTemplate(isolate, currentWorldType));
+    instance->SetInternalFieldCount(${v8ClassName}::internalFieldCount);
+    result->SetClassName(v8::String::NewSymbol("${implClassName}"));
+    result->Inherit(${v8ClassName}::GetTemplate(isolate, currentWorldType));
 
     cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(isolate, result);
     return cachedTemplate;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructorHeader
 {
     AddToImplIncludes("bindings/v8/V8ObjectConstructor.h");
     my $content = <<END;
     if (!args.IsConstructCall())
         return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
 
     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
         return args.Holder();
 
 END
     return $content;
 }
 
 sub GenerateBatchedAttributeData
 {
     my $interface = shift;
     my $attributes = shift;
     my $code = "";
-    my $interfaceName = $interface->name;
 
     foreach my $attribute (@$attributes) {
         my $conditionalString = GenerateConditionalString($attribute->signature);
         my $subCode = "";
         $subCode .= "#if ${conditionalString}\n" if $conditionalString;
-        $subCode .= GenerateSingleBatchedAttribute($interfaceName, $attribute, ",", "");
+        $subCode .= GenerateSingleBatchedAttribute($interface, $attribute, ",", "");
         $subCode .= "#endif // ${conditionalString}\n" if $conditionalString;
         $code .= $subCode;
     }
     return $code;
 }
 
 sub GenerateSingleBatchedAttribute
 {
-    my $interfaceName = shift;
+    my $interface = shift;
     my $attribute = shift;
     my $delimiter = shift;
     my $indent = shift;
     my $code = "";
     my $attrName = $attribute->signature->name;
     my $attrExt = $attribute->signature->extendedAttributes;
+    my $implClassName = GetImplClassName($interface);
 
     my $accessControl = "v8::DEFAULT";
     if ($attrExt->{"DoNotCheckSecurityOnGetter"}) {
         $accessControl = "v8::ALL_CAN_READ";
     } elsif ($attrExt->{"DoNotCheckSecurityOnSetter"}) {
         $accessControl = "v8::ALL_CAN_WRITE";
     } elsif ($attrExt->{"DoNotCheckSecurity"}) {
         $accessControl = "v8::ALL_CAN_READ";
         if (!IsReadonly($attribute)) {
             $accessControl .= " | v8::ALL_CAN_WRITE";
         }
     }
     if ($attrExt->{"Unforgeable"}) {
         $accessControl .= " | v8::PROHIBITS_OVERWRITING";
     }
     $accessControl = "static_cast<v8::AccessControl>(" . $accessControl . ")";
 
     my $customAccessor = HasCustomGetter($attrExt) || HasCustomSetter($attrExt) || "";
     if ($customAccessor eq "VALUE_IS_MISSING") {
         # use the naming convension, interface + (capitalize) attr name
-        $customAccessor = $interfaceName . "::" . $attrName;
+        $customAccessor = $implClassName . "::" . $attrName;
     }
 
     my $getter;
     my $setter;
     my $getterForMainWorld;
     my $setterForMainWorld;
     my $propAttr = "v8::None";
 
     my $isConstructor = ($attribute->signature->type =~ /Constructor$/);
 
@@ skipping 14 matching lines @@
     if ($isConstructor) {
         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"});
         }
         $data = "&V8${constructorType}::info";
-        $getter = "${interfaceName}V8Internal::${interfaceName}ConstructorGetter";
-        $setter = "${interfaceName}V8Internal::${interfaceName}ReplaceableAttrSetterCallback";
+        $getter = "${implClassName}V8Internal::${implClassName}ConstructorGetter";
+        $setter = "${implClassName}V8Internal::${implClassName}ReplaceableAttrSetterCallback";
         $getterForMainWorld = "0";
         $setterForMainWorld = "0";
     } else {
         # Default Getter and Setter
-        $getter = "${interfaceName}V8Internal::${attrName}AttrGetterCallback";
-        $setter = "${interfaceName}V8Internal::${attrName}AttrSetterCallback";
+        $getter = "${implClassName}V8Internal::${attrName}AttrGetterCallback";
+        $setter = "${implClassName}V8Internal::${attrName}AttrSetterCallback";
         $getterForMainWorld = "${getter}ForMainWorld";
         $setterForMainWorld = "${setter}ForMainWorld";
 
         if (!HasCustomSetter($attrExt) && $attrExt->{"Replaceable"}) {
-            $setter = "${interfaceName}V8Internal::${interfaceName}ReplaceableAttrSetterCallback";
+            $setter = "${implClassName}V8Internal::${implClassName}ReplaceableAttrSetterCallback";
             $setterForMainWorld = "0";
         }
     }
 
     # Read only attributes
     if (IsReadonly($attribute)) {
         $setter = "0";
         $setterForMainWorld = "0";
     }
 
@@ skipping 33 matching lines @@
     return 0 if $attrExt->{"ReadOnly"};
     return 1;
 }
 
 sub GenerateNonStandardFunction
 {
     my $interface = shift;
     my $function = shift;
     my $code = "";
 
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
     my $attrExt = $function->signature->extendedAttributes;
     my $name = $function->signature->name;
 
     my $property_attributes = "v8::DontDelete";
     if ($attrExt->{"NotEnumerable"}) {
         $property_attributes .= " | v8::DontEnum";
     }
     if ($attrExt->{"ReadOnly"}) {
         $property_attributes .= " | v8::ReadOnly";
     }
@@ skipping 21 matching lines @@
     }
 
     if ($interface->extendedAttributes->{"CheckSecurity"} && $attrExt->{"DoNotCheckSecurity"}) {
         # Functions that are marked DoNotCheckSecurity are always readable but if they are changed
         # and then accessed on a different domain we do not return the underlying value but instead
         # return a new copy of the original function. This is achieved by storing the changed value
         # as hidden property.
         $code .= <<END;
 
     // $commentInfo
-    ${conditional}$template->SetAccessor(v8::String::NewSymbol("$name"), ${interfaceName}V8Internal::${name}AttrGetterCallback, ${interfaceName}V8Internal::${interfaceName}DomainSafeFunctionSetter, v8Undefined(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>($property_attributes));
+    ${conditional}$template->SetAccessor(v8::String::NewSymbol("$name"), ${implClassName}V8Internal::${name}AttrGetterCallback, ${implClassName}V8Internal::${implClassName}DomainSafeFunctionSetter, v8Undefined(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>($property_attributes));
 END
         return $code;
     }
 
     my $signature = "defaultSignature";
     if ($attrExt->{"DoNotCheckSignature"} || $function->isStatic) {
        $signature = "v8::Local<v8::Signature>()";
     }
 
     if (RequiresCustomSignature($function)) {
         $signature = "${name}Signature";
         $code .= "\n    // Custom Signature '$name'\n" . CreateCustomSignature($function);
     }
 
     if ($property_attributes eq "v8::DontDelete") {
         $property_attributes = "";
     } else {
         $property_attributes = ", static_cast<v8::PropertyAttribute>($property_attributes)";
     }
 
     if ($template eq "proto" && $conditional eq "" && $signature eq "defaultSignature" && $property_attributes eq "") {
-        die "This shouldn't happen: Intraface '$interfaceName' $commentInfo\n";
+        die "This shouldn't happen: Class '$implClassName' $commentInfo\n";
     }
 
     my $functionLength = GetFunctionLength($function);
 
     my $conditionalString = GenerateConditionalString($function->signature);
     $code .= "#if ${conditionalString}\n" if $conditionalString;
     if ($function->signature->extendedAttributes->{"PerWorldBindings"}) {
         $code .= "    if (currentWorldType == MainWorld) {\n";
-        $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallbackForMainWorld, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
+        $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallbackForMainWorld, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
         $code .= "    } else {\n";
-        $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
+        $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
         $code .= "    }\n";
     } else {
-        $code .= "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
+        $code .= "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
     }
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     return $code;
 }
 
 sub GenerateImplementationIndexedProperty
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     my $indexedGetterfunction = GetIndexedGetterFunction($interface);
     my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
     my $hasCustomIndexedGetter = $interface->extendedAttributes->{"CustomIndexedGetter"};
 
     if (!$indexedGetterfunction && !$hasCustomIndexedGetter) {
         return "";
     }
 
     my $hasEnumerator = 1;
@@ skipping 12 matching lines @@
 
     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
     # get implementation straight out of the DOMWindow prototype regardless of what prototype is actually set
     # on the object.
     if ($interfaceName eq "DOMWindow") {
         $setOn = "Prototype";
     }
 
     my $code = "";
-    $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8InterfaceName}::indexedPropertyGetter";
-    $code .= $hasCustomIndexedSetter ? ", ${v8InterfaceName}::indexedPropertySetter" : ", 0";
+    $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8ClassName}::indexedPropertyGetter";
+    $code .= $hasCustomIndexedSetter ? ", ${v8ClassName}::indexedPropertySetter" : ", 0";
     $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
-    $code .= $hasDeleter ? ", ${v8InterfaceName}::indexedPropertyDeleter" : ", 0";
-    $code .= ", nodeCollectionIndexedPropertyEnumerator<${interfaceName}>" if $hasEnumerator;
+    $code .= $hasDeleter ? ", ${v8ClassName}::indexedPropertyDeleter" : ", 0";
+    $code .= ", nodeCollectionIndexedPropertyEnumerator<${implClassName}>" if $hasEnumerator;
     $code .= ");\n";
 
     if ($indexedGetterfunction && !$hasCustomIndexedGetter) {
         my $returnType = $indexedGetterfunction->signature->type;
         my $methodName = $indexedGetterfunction->signature->name || "anonymousIndexedGetter";
         AddToImplIncludes("bindings/v8/V8Collection.h");
         my $jsValue = "";
         my $nativeType = GetNativeType($returnType);
         my $isNull = "";
 
         if (IsRefPtrType($returnType)) {
             AddToImplIncludes("V8$returnType.h");
             $isNull = "!element";
             $jsValue = NativeToJSValue($indexedGetterfunction->signature, "element.release()", "info.Holder()", "info.GetIsolate()", "info", "collection", "", "");
         } else {
             $isNull = "element.isNull()";
             $jsValue = NativeToJSValue($indexedGetterfunction->signature, "element", "info.Holder()", "info.GetIsolate()");
         }
 
         $implementation{nameSpaceWebCore}->add(<<END);
-v8::Handle<v8::Value> ${v8InterfaceName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)
+v8::Handle<v8::Value> ${v8ClassName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)
 {
     ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
-    ${interfaceName}* collection = toNative(info.Holder());
+    ${implClassName}* collection = toNative(info.Holder());
     $nativeType element = collection->$methodName(index);
     if ($isNull)
         return v8Undefined();
     return $jsValue;
 }
 END
     }
     return $code;
 }
 
 sub GenerateImplementationNamedPropertyGetter
 {
     my $interface = shift;
 
     my $subCode = "";
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     my $namedGetterFunction = GetNamedGetterFunction($interface);
     my $hasCustomNamedGetter = $interface->extendedAttributes->{"CustomNamedGetter"};
 
     if ($namedGetterFunction && !$hasCustomNamedGetter) {
         my $returnType = $namedGetterFunction->signature->type;
         my $methodName = $namedGetterFunction->signature->name;
         AddToImplIncludes("bindings/v8/V8Collection.h");
         AddToImplIncludes("V8$returnType.h");
         $subCode .= <<END;
-    desc->InstanceTemplate()->SetNamedPropertyHandler(${v8InterfaceName}::namedPropertyGetter, 0, 0, 0, 0);
+    desc->InstanceTemplate()->SetNamedPropertyHandler(${v8ClassName}::namedPropertyGetter, 0, 0, 0, 0);
 END
 
         my $code .= <<END;
-v8::Handle<v8::Value> ${v8InterfaceName}::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+v8::Handle<v8::Value> ${v8ClassName}::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
         return v8Undefined();
     if (info.Holder()->HasRealNamedCallbackProperty(name))
         return v8Undefined();
 
     v8::Local<v8::Object> object = info.Holder();
     ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
-    $interfaceName* collection = toNative(object);
+    $implClassName* collection = toNative(object);
 
     AtomicString propertyName = toWebCoreAtomicString(name);
     RefPtr<$returnType> element = collection->$methodName(propertyName);
 
     if (!element)
         return v8Undefined();
 
     return toV8Fast(element.release(), info, collection);
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if ($hasCustomNamedGetter) {
         my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
         my $hasDeleter = $interface->extendedAttributes->{"CustomDeleteProperty"};
         my $hasEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
         my $setOn = "Instance";
 
         # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
         # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
         # get implementation straight out of the DOMWindow prototype regardless of what prototype is actually set
         # on the object.
         if ($interfaceName eq "DOMWindow") {
             $setOn = "Prototype";
         }
 
-        $subCode .= "    desc->${setOn}Template()->SetNamedPropertyHandler(${v8InterfaceName}::namedPropertyGetter, ";
-        $subCode .= $hasCustomNamedSetter ? "${v8InterfaceName}::namedPropertySetter, " : "0, ";
+        $subCode .= "    desc->${setOn}Template()->SetNamedPropertyHandler(${v8ClassName}::namedPropertyGetter, ";
+        $subCode .= $hasCustomNamedSetter ? "${v8ClassName}::namedPropertySetter, " : "0, ";
         # If there is a custom enumerator, there MUST be custom query to properly communicate property attributes.
-        $subCode .= $hasEnumerator ? "${v8InterfaceName}::namedPropertyQuery, " : "0, ";
-        $subCode .= $hasDeleter ? "${v8InterfaceName}::namedPropertyDeleter, " : "0, ";
-        $subCode .= $hasEnumerator ? "${v8InterfaceName}::namedPropertyEnumerator" : "0";
+        $subCode .= $hasEnumerator ? "${v8ClassName}::namedPropertyQuery, " : "0, ";
+        $subCode .= $hasDeleter ? "${v8ClassName}::namedPropertyDeleter, " : "0, ";
+        $subCode .= $hasEnumerator ? "${v8ClassName}::namedPropertyEnumerator" : "0";
         $subCode .= ");\n";
     }
 
     return $subCode;
 }
 
 sub GenerateImplementationCustomCall
 {
     my $interface = shift;
     my $code = "";
 
-    my $interfaceName = $interface->name;
+    my $v8ClassName = GetV8ClassName($interface);
 
     if ($interface->extendedAttributes->{"CustomCall"}) {
-        $code .= "    desc->InstanceTemplate()->SetCallAsFunctionHandler(V8${interfaceName}::callAsFunctionCallback);\n";
+        $code .= "    desc->InstanceTemplate()->SetCallAsFunctionHandler(${v8ClassName}::callAsFunctionCallback);\n";
     }
     return $code;
 }
 
 sub GenerateImplementationMasqueradesAsUndefined
 {
     my $interface = shift;
     my $code = "";
 
     if ($interface->extendedAttributes->{"MasqueradesAsUndefined"})
     {
         $code .= "    desc->InstanceTemplate()->MarkAsUndetectable();\n";
     }
     return $code;
 }
 
 sub GenerateImplementation
 {
     my $object = shift;
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $visibleInterfaceName = GetVisibleInterfaceName($interface);
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
     my $nativeType = GetNativeTypeForConversions($interface);
     my $vtableNameGnu = GetGnuVTableNameForInterface($interface);
     my $vtableRefGnu = GetGnuVTableRefForInterface($interface);
     my $vtableRefWin = GetWinVTableRefForInterface($interface);
 
     AddToImplIncludes("bindings/v8/V8Binding.h");
     AddToImplIncludes("bindings/v8/V8DOMWrapper.h");
     AddToImplIncludes("core/dom/ContextFeatures.h");
     AddToImplIncludes("core/dom/Document.h");
     AddToImplIncludes("RuntimeEnabledFeatures.h");
 
     AddExtraIncludesForType($interfaceName);
 
-    my $toActiveDOMObject = InheritsExtendedAttribute($interface, "ActiveDOMObject") ? "${v8InterfaceName}::toActiveDOMObject" : "0";
-    my $toEventTarget = InheritsExtendedAttribute($interface, "EventTarget") ? "${v8InterfaceName}::toEventTarget" : "0";
-    my $rootForGC = NeedsCustomOpaqueRootForGC($interface) ? "${v8InterfaceName}::opaqueRootForGC" : "0";
+    my $toActiveDOMObject = InheritsExtendedAttribute($interface, "ActiveDOMObject") ? "${v8ClassName}::toActiveDOMObject" : "0";
+    my $toEventTarget = InheritsExtendedAttribute($interface, "EventTarget") ? "${v8ClassName}::toEventTarget" : "0";
+    my $rootForGC = NeedsCustomOpaqueRootForGC($interface) ? "${v8ClassName}::opaqueRootForGC" : "0";
 
     # Find the super descriptor.
     my $parentClass = "";
     my $parentClassTemplate = "";
     foreach (@{$interface->parents}) {
         my $parent = $_;
         AddToImplIncludes("V8${parent}.h");
         $parentClass = "V8" . $parent;
         $parentClassTemplate = $parentClass . "::GetTemplate(isolate, currentWorldType)";
         last;
@@ skipping 39 matching lines @@
     my $parentClassInfo = $parentClass ? "&${parentClass}::info" : "0";
     my $WrapperTypePrototype = $interface->isException ? "WrapperTypeErrorPrototype" : "WrapperTypeObjectPrototype";
 
     if (!IsSVGTypeNeedingTearOff($interfaceName)) {
         my $code = <<END;
 #if defined(OS_WIN)
 // In ScriptWrappable, the use of extern function prototypes inside templated static methods has an issue on windows.
 // These prototypes do not pick up the surrounding namespace, so drop out of WebCore as a workaround.
 } // namespace WebCore
 using WebCore::ScriptWrappable;
-using WebCore::${v8InterfaceName};
+using WebCore::${v8ClassName};
 END
         $code .= <<END if (GetNamespaceForInterface($interface) eq "WebCore");
-using WebCore::${interfaceName};
+using WebCore::${implClassName};
 END
         $code .= <<END;
 #endif
-void initializeScriptWrappableForInterface(${interfaceName}* object)
+void initializeScriptWrappableForInterface(${implClassName}* object)
 {
     if (ScriptWrappable::wrapperCanBeStoredInObject(object))
-        ScriptWrappable::setTypeInfoInObject(object, &${v8InterfaceName}::info);
+        ScriptWrappable::setTypeInfoInObject(object, &${v8ClassName}::info);
 }
 #if defined(OS_WIN)
 namespace WebCore {
 #endif
 END
         $implementation{nameSpaceWebCore}->addHeader($code);
     }
 
-    my $code = "WrapperTypeInfo ${v8InterfaceName}::info = { ${v8InterfaceName}::GetTemplate, ${v8InterfaceName}::derefObject, $toActiveDOMObject, $toEventTarget, ";
-    $code .= "$rootForGC, ${v8InterfaceName}::installPerContextPrototypeProperties, $parentClassInfo, $WrapperTypePrototype };\n";
+    my $code = "WrapperTypeInfo ${v8ClassName}::info = { ${v8ClassName}::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, ";
+    $code .= "$rootForGC, ${v8ClassName}::installPerContextPrototypeProperties, $parentClassInfo, $WrapperTypePrototype };\n";
     $implementation{nameSpaceWebCore}->addHeader($code);
 
     $implementation{nameSpaceInternal}->add("template <typename T> void V8_USE(T) { }\n\n");
 
     my $hasConstructors = 0;
     my $hasReplaceable = 0;
 
     # Generate property accessors for attributes.
     for (my $index = 0; $index < @{$interface->attributes}; $index++) {
         my $attribute = @{$interface->attributes}[$index];
@@ skipping 47 matching lines @@
         GenerateOpaqueRootForGC($interface);
     }
 
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interface->name ne "DOMWindow") {
         GenerateSecurityCheckFunctions($interface);
     }
 
     if ($interface->extendedAttributes->{"TypedArray"}) {
         my $viewType = GetTypeNameOfExternalTypedArray($interface);
         $implementation{nameSpaceWebCore}->add(<<END);
-v8::Handle<v8::Object> wrap($interfaceName* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+v8::Handle<v8::Object> wrap($implClassName* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
-    v8::Handle<v8::Object> wrapper = ${v8InterfaceName}::createWrapper(impl, creationContext, isolate);
+    v8::Handle<v8::Object> wrapper = ${v8ClassName}::createWrapper(impl, creationContext, isolate);
     if (!wrapper.IsEmpty())
         wrapper->SetIndexedPropertiesToExternalArrayData(impl->baseAddress(), $viewType, impl->length());
     return wrapper;
 }
 
 END
     }
 
     my $indexer;
     my @enabledPerContextFunctions;
@@ skipping 20 matching lines @@
 
         if ($function->signature->name eq "item") {
             $indexer = $function->signature;
         }
 
         # If the function does not need domain security check, we need to
         # generate an access getter that returns different function objects
         # for different calling context.
         if ($interface->extendedAttributes->{"CheckSecurity"} && $function->signature->extendedAttributes->{"DoNotCheckSecurity"}) {
             if (!HasCustomMethod($function->signature->extendedAttributes) || $function->{overloadIndex} == 1) {
-                GenerateDomainSafeFunctionGetter($function, $interfaceName);
+                GenerateDomainSafeFunctionGetter($function, $interface);
                 $needsDomainSafeFunctionSetter = 1;
             }
         }
 
         # Separate out functions that are enabled per context so we can process them specially.
         if ($function->signature->extendedAttributes->{"EnabledPerContext"}) {
             push(@enabledPerContextFunctions, $function);
         } else {
             push(@normalFunctions, $function);
         }
     }
 
     if ($needsDomainSafeFunctionSetter) {
-        GenerateDomainSafeFunctionSetter($interfaceName);
+        GenerateDomainSafeFunctionSetter($interface);
     }
 
     # Attributes
     my $attributes = $interface->attributes;
 
     # For the DOMWindow interface we partition the attributes into the
     # ones that disallows shadowing and the rest.
     my @disallowsShadowing;
     # Also separate out attributes that are enabled at runtime so we can process them specially.
     my @enabledAtRuntimeAttributes;
@@ skipping 22 matching lines @@
         $code .= "static const V8DOMConfiguration::BatchedAttribute shadowAttrs[] = {\n";
         $code .= GenerateBatchedAttributeData($interface, \@disallowsShadowing);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     my $has_attributes = 0;
     if (@$attributes) {
         $has_attributes = 1;
         my $code = "";
-        $code .= "static const V8DOMConfiguration::BatchedAttribute ${v8InterfaceName}Attrs[] = {\n";
+        $code .= "static const V8DOMConfiguration::BatchedAttribute ${v8ClassName}Attrs[] = {\n";
         $code .= GenerateBatchedAttributeData($interface, $attributes);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     # Setup table of standard callback functions
     my $num_callbacks = 0;
     my $has_callbacks = 0;
     $code = "";
     foreach my $function (@normalFunctions) {
         # Only one table entry is needed for overloaded methods:
         next if $function->{overloadIndex} > 1;
         # Don't put any nonstandard functions into this table:
         next if !IsStandardFunction($interface, $function);
         next if $function->signature->name eq "";
         if (!$has_callbacks) {
             $has_callbacks = 1;
-            $code .= "static const V8DOMConfiguration::BatchedMethod ${v8InterfaceName}Methods[] = {\n";
+            $code .= "static const V8DOMConfiguration::BatchedMethod ${v8ClassName}Methods[] = {\n";
         }
         my $name = $function->signature->name;
         my $methodForMainWorld = "0";
         if ($function->signature->extendedAttributes->{"PerWorldBindings"}) {
-            $methodForMainWorld = "${interfaceName}V8Internal::${name}MethodCallbackForMainWorld";
+            $methodForMainWorld = "${implClassName}V8Internal::${name}MethodCallbackForMainWorld";
         }
         my $functionLength = GetFunctionLength($function);
         my $conditionalString = GenerateConditionalString($function->signature);
         $code .= "#if ${conditionalString}\n" if $conditionalString;
         $code .= <<END;
-    {"$name", ${interfaceName}V8Internal::${name}MethodCallback, ${methodForMainWorld}, ${functionLength}},
+    {"$name", ${implClassName}V8Internal::${name}MethodCallback, ${methodForMainWorld}, ${functionLength}},
 END
         $code .= "#endif\n" if $conditionalString;
         $num_callbacks++;
     }
     $code .= "};\n\n"  if $has_callbacks;
     $implementation{nameSpaceWebCore}->add($code);
 
     # Setup constants
     my $has_constants = 0;
     my @constantsEnabledAtRuntime;
     $code = "";
     if (@{$interface->constants}) {
         $has_constants = 1;
-        $code .= "static const V8DOMConfiguration::BatchedConstant ${v8InterfaceName}Consts[] = {\n";
+        $code .= "static const V8DOMConfiguration::BatchedConstant ${v8ClassName}Consts[] = {\n";
     }
     foreach my $constant (@{$interface->constants}) {
         my $name = $constant->name;
         my $value = $constant->value;
         my $attrExt = $constant->extendedAttributes;
         my $implementedBy = $attrExt->{"ImplementedBy"};
         if ($implementedBy) {
             AddInterfaceToImplIncludes($implementedBy);
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
@@ skipping 28 matching lines @@
         } elsif (IsConstructorTemplate($interface, "TypedArray")) {
             GenerateTypedArrayConstructor($interface);
         }
     }
     if (IsConstructable($interface)) {
         GenerateConstructorCallback($interface);
     }
 
     my $access_check = "";
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "DOMWindow") {
-        $access_check = "instance->SetAccessCheckCallbacks(${interfaceName}V8Internal::namedSecurityCheck, ${interfaceName}V8Internal::indexedSecurityCheck, v8::External::New(&${v8InterfaceName}::info));";
+        $access_check = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(&${v8ClassName}::info));";
     }
 
     # For the DOMWindow interface, generate the shadow object template
     # configuration method.
     if ($interfaceName eq "DOMWindow") {
         $implementation{nameSpaceWebCore}->add(<<END);
 static v8::Persistent<v8::ObjectTemplate> ConfigureShadowObjectTemplate(v8::Persistent<v8::ObjectTemplate> templ, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     V8DOMConfiguration::batchConfigureAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttrs, WTF_ARRAY_LENGTH(shadowAttrs), isolate, currentWorldType);
 
     // Install a security handler with V8.
     templ->SetAccessCheckCallbacks(V8DOMWindow::namedSecurityCheckCustom, V8DOMWindow::indexedSecurityCheckCustom, v8::External::New(&V8DOMWindow::info));
     templ->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
     return templ;
 }
 END
     }
 
     if (!$parentClassTemplate) {
         $parentClassTemplate = "v8::Persistent<v8::FunctionTemplate>()";
     }
 
     # Generate the template configuration method
     $code =  <<END;
-static v8::Persistent<v8::FunctionTemplate> Configure${v8InterfaceName}Template(v8::Persistent<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
+static v8::Persistent<v8::FunctionTemplate> Configure${v8ClassName}Template(v8::Persistent<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     desc->ReadOnlyPrototype();
 
     v8::Local<v8::Signature> defaultSignature;
 END
     if ($interface->extendedAttributes->{"EnabledAtRuntime"}) {
         my $enable_function = GetRuntimeEnableFunctionName($interface);
         $code .= <<END;
     if (!${enable_function}())
-        defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"\", $parentClassTemplate, ${v8InterfaceName}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
+        defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
     else
 END
     }
     $code .=  <<END;
-    defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"${visibleInterfaceName}\", $parentClassTemplate, ${v8InterfaceName}::internalFieldCount,
+    defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"${visibleInterfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount,
 END
     # Set up our attributes if we have them
     if ($has_attributes) {
         $code .= <<END;
-        ${v8InterfaceName}Attrs, WTF_ARRAY_LENGTH(${v8InterfaceName}Attrs),
+        ${v8ClassName}Attrs, WTF_ARRAY_LENGTH(${v8ClassName}Attrs),
 END
     } else {
         $code .= <<END;
         0, 0,
 END
     }
 
     if ($has_callbacks) {
         $code .= <<END;
-        ${v8InterfaceName}Methods, WTF_ARRAY_LENGTH(${v8InterfaceName}Methods), isolate, currentWorldType);
+        ${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), isolate, currentWorldType);
 END
     } else {
         $code .= <<END;
         0, 0, isolate, currentWorldType);
 END
     }
 
     AddToImplIncludes("wtf/UnusedParam.h");
     $code .= <<END;
     UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
 END
 
     if (IsConstructable($interface)) {
-        $code .= "    desc->SetCallHandler(${v8InterfaceName}::constructorCallback);\n";
+        $code .= "    desc->SetCallHandler(${v8ClassName}::constructorCallback);\n";
         my $interfaceLength = GetInterfaceLength($interface);
         $code .= "    desc->SetLength(${interfaceLength});\n";
     }
 
     if ($access_check or @enabledAtRuntimeAttributes or @normalFunctions or $has_constants) {
         $code .=  <<END;
     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
     UNUSED_PARAM(instance); // In some cases, it will not be used.
     UNUSED_PARAM(proto); // In some cases, it will not be used.
 END
     }
 
     if ($access_check) {
         $code .=  "    $access_check\n";
     }
 
     # Setup the enable-at-runtime attrs if we have them
     foreach my $runtime_attr (@enabledAtRuntimeAttributes) {
         next if grep { $_ eq $runtime_attr } @enabledPerContextAttributes;
         my $enable_function = GetRuntimeEnableFunctionName($runtime_attr->signature);
         my $conditionalString = GenerateConditionalString($runtime_attr->signature);
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\n";
         $code .= "        static const V8DOMConfiguration::BatchedAttribute attrData =\\\n";
-        $code .= GenerateSingleBatchedAttribute($interfaceName, $runtime_attr, ";", "    ");
+        $code .= GenerateSingleBatchedAttribute($interface, $runtime_attr, ";", "    ");
         $code .= <<END;
         V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType);
     }
 END
         $code .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
 
     # Setup the enable-at-runtime constants if we have them
     foreach my $runtime_const (@constantsEnabledAtRuntime) {
         my $enable_function = GetRuntimeEnableFunctionName($runtime_const);
@@ skipping 25 matching lines @@
         $total_functions++;
         next if IsStandardFunction($interface, $function);
         $code .= GenerateNonStandardFunction($interface, $function);
         $num_callbacks++;
     }
 
     die "Wrong number of callbacks generated for $interfaceName ($num_callbacks, should be $total_functions)" if $num_callbacks != $total_functions;
 
     if ($has_constants) {
         $code .= <<END;
-    V8DOMConfiguration::batchConfigureConstants(desc, proto, ${v8InterfaceName}Consts, WTF_ARRAY_LENGTH(${v8InterfaceName}Consts), isolate);
+    V8DOMConfiguration::batchConfigureConstants(desc, proto, ${v8ClassName}Consts, WTF_ARRAY_LENGTH(${v8ClassName}Consts), isolate);
 END
     }
 
     # Special cases
     if ($interfaceName eq "DOMWindow") {
         $code .= <<END;
 
     proto->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
     desc->SetHiddenPrototype(true);
     instance->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
@@ skipping 23 matching lines @@
 
     // Custom toString template
     desc->Set(v8::String::NewSymbol("toString"), V8PerIsolateData::current()->toStringTemplate());
     return desc;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
     $implementation{nameSpaceWebCore}->add(<<END);
-v8::Persistent<v8::FunctionTemplate> ${v8InterfaceName}::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
+v8::Persistent<v8::FunctionTemplate> ${v8ClassName}::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&info);
     if (result != data->templateMap(currentWorldType).end())
         return result->value;
 
     v8::HandleScope handleScope;
     v8::Persistent<v8::FunctionTemplate> templ =
-        Configure${v8InterfaceName}Template(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType);
+        Configure${v8ClassName}Template(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType);
     data->templateMap(currentWorldType).add(&info, templ);
     return templ;
 }
 
 END
     $implementation{nameSpaceWebCore}->add(<<END);
-bool ${v8InterfaceName}::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType)
+bool ${v8ClassName}::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     return V8PerIsolateData::from(isolate)->hasInstance(&info, value, currentWorldType);
 }
 
 END
     $implementation{nameSpaceWebCore}->add(<<END);
-bool ${v8InterfaceName}::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
+bool ${v8ClassName}::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld);
 }
 
 END
 
     if (@enabledPerContextAttributes) {
         my $code = "";
         $code .= <<END;
-void ${v8InterfaceName}::installPerContextProperties(v8::Handle<v8::Object> instance, ${nativeType}* impl, v8::Isolate* isolate)
+void ${v8ClassName}::installPerContextProperties(v8::Handle<v8::Object> instance, ${nativeType}* impl, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype());
 END
 
         # Setup the enable-by-settings attrs if we have them
         foreach my $runtimeAttr (@enabledPerContextAttributes) {
             my $enableFunction = GetContextEnableFunction($runtimeAttr->signature);
             my $conditionalString = GenerateConditionalString($runtimeAttr->signature);
             $code .= "\n#if ${conditionalString}\n" if $conditionalString;
             if (grep { $_ eq $runtimeAttr } @enabledAtRuntimeAttributes) {
                 my $runtimeEnableFunction = GetRuntimeEnableFunctionName($runtimeAttr->signature);
                 $code .= "    if (${enableFunction}(impl->document()) && ${runtimeEnableFunction}()) {\n";
             } else {
                 $code .= "    if (${enableFunction}(impl->document())) {\n";
             }
 
             $code .= "        static const V8DOMConfiguration::BatchedAttribute attrData =\\\n";
-            $code .= GenerateSingleBatchedAttribute($interfaceName, $runtimeAttr, ";", "    ");
+            $code .= GenerateSingleBatchedAttribute($interface, $runtimeAttr, ";", "    ");
             $code .= <<END;
         V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
 END
             $code .= "    }\n";
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         }
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if (@enabledPerContextFunctions) {
         my $code = "";
         $code .= <<END;
-void ${v8InterfaceName}::installPerContextPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
+void ${v8ClassName}::installPerContextPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
 {
     UNUSED_PARAM(proto);
 END
         # Setup the enable-by-settings functions if we have them
         $code .=  <<END;
     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(GetTemplate(isolate, worldType(isolate)));
     UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
 
     ScriptExecutionContext* context = toScriptExecutionContext(proto->CreationContext());
 END
 
         foreach my $runtimeFunc (@enabledPerContextFunctions) {
             my $enableFunction = GetContextEnableFunction($runtimeFunc->signature);
             my $functionLength = GetFunctionLength($runtimeFunc);
             my $conditionalString = GenerateConditionalString($runtimeFunc->signature);
             $code .= "\n#if ${conditionalString}\n" if $conditionalString;
             $code .= "    if (context && context->isDocument() && ${enableFunction}(toDocument(context))) {\n";
             my $name = $runtimeFunc->signature->name;
             $code .= <<END;
-        proto->Set(v8::String::NewSymbol("${name}"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), defaultSignature, $functionLength)->GetFunction());
+        proto->Set(v8::String::NewSymbol("${name}"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), defaultSignature, $functionLength)->GetFunction());
 END
             $code .= "    }\n";
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         }
 
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         # MessagePort is handled like an active dom object even though it doesn't inherit
         # from ActiveDOMObject, so don't try to cast it to ActiveDOMObject.
         my $returnValue = $interfaceName eq "MessagePort" ? "0" : "toNative(object)";
         $implementation{nameSpaceWebCore}->add(<<END);
-ActiveDOMObject* ${v8InterfaceName}::toActiveDOMObject(v8::Handle<v8::Object> object)
+ActiveDOMObject* ${v8ClassName}::toActiveDOMObject(v8::Handle<v8::Object> object)
 {
     return $returnValue;
 }
 
 END
     }
 
     if (InheritsExtendedAttribute($interface, "EventTarget")) {
         $implementation{nameSpaceWebCore}->add(<<END);
-EventTarget* ${v8InterfaceName}::toEventTarget(v8::Handle<v8::Object> object)
+EventTarget* ${v8ClassName}::toEventTarget(v8::Handle<v8::Object> object)
 {
     return toNative(object);
 }
 
 END
     }
 
     if ($interfaceName eq "DOMWindow") {
         $implementation{nameSpaceWebCore}->add(<<END);
 v8::Persistent<v8::ObjectTemplate> V8DOMWindow::GetShadowObjectTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
@@ skipping 11 matching lines @@
             V8DOMWindowShadowObjectCacheForNonMainWorld = v8::Persistent<v8::ObjectTemplate>::New(isolate, v8::ObjectTemplate::New());
             ConfigureShadowObjectTemplate(V8DOMWindowShadowObjectCacheForNonMainWorld, isolate, currentWorldType);
         }
         return V8DOMWindowShadowObjectCacheForNonMainWorld;
     }
 }
 
 END
     }
 
-    GenerateToV8Converters($interface, $v8InterfaceName, $nativeType);
+    GenerateToV8Converters($interface, $v8ClassName, $nativeType);
 
     $implementation{nameSpaceWebCore}->add(<<END);
-void ${v8InterfaceName}::derefObject(void* object)
+void ${v8ClassName}::derefObject(void* object)
 {
     static_cast<${nativeType}*>(object)->deref();
 }
 
 END
 }
 
 sub GenerateHeaderContentHeader
 {
     my $interface = shift;
-    my $v8InterfaceName = "V8" . $interface->name;
+    my $v8ClassName = GetV8ClassName($interface);
     my $conditionalString = GenerateConditionalString($interface);
 
     my @headerContentHeader = split("\r", $headerTemplate);
 
-    push(@headerContentHeader, "\n#ifndef ${v8InterfaceName}" . "_h\n");
-    push(@headerContentHeader, "#define ${v8InterfaceName}" . "_h\n\n");
+    push(@headerContentHeader, "\n#ifndef ${v8ClassName}" . "_h\n");
+    push(@headerContentHeader, "#define ${v8ClassName}" . "_h\n\n");
     push(@headerContentHeader, "#if ${conditionalString}\n") if $conditionalString;
     return join "", @headerContentHeader;
 }
 
 sub GenerateCallbackHeader
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     $header{root}->addFooter("\n");
 
     my @unsortedIncludes = ();
     push(@unsortedIncludes, "#include \"bindings/v8/ActiveDOMCallback.h\"");
     push(@unsortedIncludes, "#include \"bindings/v8/DOMWrapperWorld.h\"");
     push(@unsortedIncludes, "#include \"bindings/v8/ScopedPersistent.h\"");
-    my $interfaceHeader = HeaderFileForInterface($interfaceName);
+    my $interfaceHeader = HeaderFileForInterface($interfaceName, $implClassName);
     push(@unsortedIncludes, "#include \"$interfaceHeader\"");
     push(@unsortedIncludes, "#include <v8.h>");
     push(@unsortedIncludes, "#include \"wtf/Forward.h\"");
     $header{includes}->add(join("\n", sort @unsortedIncludes));
     unshift(@{$header{nameSpaceWebCore}->{header}}, "\n");
     $header{nameSpaceWebCore}->addHeader("class ScriptExecutionContext;\n\n");
-    $header{class}->addHeader("class $v8InterfaceName : public $interfaceName, public ActiveDOMCallback {");
+    $header{class}->addHeader("class $v8ClassName : public $implClassName, public ActiveDOMCallback {");
     $header{class}->addFooter("};\n");
 
     $header{classPublic}->add(<<END);
-    static PassRefPtr<${v8InterfaceName}> create(v8::Handle<v8::Value> value, ScriptExecutionContext* context)
+    static PassRefPtr<${v8ClassName}> create(v8::Handle<v8::Value> value, ScriptExecutionContext* context)
     {
         ASSERT(value->IsObject());
         ASSERT(context);
-        return adoptRef(new ${v8InterfaceName}(v8::Handle<v8::Object>::Cast(value), context));
+        return adoptRef(new ${v8ClassName}(v8::Handle<v8::Object>::Cast(value), context));
     }
 
-    virtual ~${v8InterfaceName}();
+    virtual ~${v8ClassName}();
 
 END
 
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         $header{classPublic}->add("    // Functions\n");
         foreach my $function (@{$interface->functions}) {
             my $code = "";
             my @params = @{$function->parameters};
@@ skipping 13 matching lines @@
             $header{classPublic}->add($code);
         }
     }
 
     $header{classPublic}->add(<<END);
 
     virtual ScriptExecutionContext* scriptExecutionContext() const { return ContextDestructionObserver::scriptExecutionContext(); }
 
 END
     $header{classPrivate}->add(<<END);
-    ${v8InterfaceName}(v8::Handle<v8::Object>, ScriptExecutionContext*);
+    ${v8ClassName}(v8::Handle<v8::Object>, ScriptExecutionContext*);
 
     ScopedPersistent<v8::Object> m_callback;
     RefPtr<DOMWrapperWorld> m_world;
 END
 }
 
 sub GenerateCallbackImplementation
 {
     my $object = shift;
     my $interface = shift;
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("core/dom/ScriptExecutionContext.h");
     AddToImplIncludes("bindings/v8/V8Binding.h");
     AddToImplIncludes("bindings/v8/V8Callback.h");
     AddToImplIncludes("wtf/Assertions.h");
 
     $implementation{nameSpaceWebCore}->add(<<END);
-${v8InterfaceName}::${v8InterfaceName}(v8::Handle<v8::Object> callback, ScriptExecutionContext* context)
+${v8ClassName}::${v8ClassName}(v8::Handle<v8::Object> callback, ScriptExecutionContext* context)
     : ActiveDOMCallback(context)
     , m_callback(callback)
     , m_world(DOMWrapperWorld::current())
 {
 }
 
 END
 
     $implementation{nameSpaceWebCore}->add(<<END);
-${v8InterfaceName}::~${v8InterfaceName}()
+${v8ClassName}::~${v8ClassName}()
 {
 }
 
 END
 
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         $implementation{nameSpaceWebCore}->add("// Functions\n");
         foreach my $function (@{$interface->functions}) {
             my $code = "";
             my @params = @{$function->parameters};
             if ($function->signature->extendedAttributes->{"Custom"} ||
                 !(GetNativeTypeForCallbacks($function->signature->type) eq "bool")) {
                 next;
             }
 
             AddIncludesForType($function->signature->type);
-            $code .= "\n" . GetNativeTypeForCallbacks($function->signature->type) . " ${v8InterfaceName}::" . $function->signature->name . "(";
+            $code .= "\n" . GetNativeTypeForCallbacks($function->signature->type) . " ${v8ClassName}::" . $function->signature->name . "(";
 
             my @args = ();
             my @argsCheck = ();
             foreach my $param (@params) {
                 my $paramName = $param->name;
                 AddIncludesForType($param->type);
                 push(@args, GetNativeTypeForCallbacks($param->type) . " " . $paramName);
             }
             $code .= join(", ", @args);
 
@@ skipping 42 matching lines @@
     while (@{$interface->parents}) {
         $interface = ParseInterface(@{$interface->parents}[0]);
     }
 
     return $interface->name;
 }
 
 sub GenerateToV8Converters
 {
     my $interface = shift;
-    my $v8InterfaceName = shift;
+    my $v8ClassName = shift;
     my $nativeType = shift;
     my $interfaceName = $interface->name;
 
     if ($interface->extendedAttributes->{"DoNotGenerateWrap"} || $interface->extendedAttributes->{"DoNotGenerateToV8"}) {
         return;
     }
 
     AddToImplIncludes("bindings/v8/ScriptController.h");
     AddToImplIncludes("core/page/Frame.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)
+v8::Handle<v8::Object> ${v8ClassName}::createWrapper(${createWrapperArgumentType} impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl.get());
     ASSERT(DOMDataStore::getWrapper(impl.get(), isolate).IsEmpty());
 END
 
     my $vtableNameGnu = GetGnuVTableNameForInterface($interface);
     $code .= <<END if $vtableNameGnu;
 
 #if ENABLE(BINDING_INTEGRITY)
     checkTypeOrDieTrying(impl.get());
@@ skipping 27 matching lines @@
     V8DOMWrapper::associateObjectWithWrapper(impl, &info, wrapper, isolate, hasDependentLifetime ? WrapperConfiguration::Dependent : WrapperConfiguration::Independent);
     return wrapper;
 }
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateSecurityCheckFunctions
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
-    my $v8InterfaceName = "V8$interfaceName";
+    my $implClassName = GetImplClassName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("bindings/v8/BindingSecurity.h");
     $implementation{nameSpaceInternal}->add(<<END);
 bool indexedSecurityCheck(v8::Local<v8::Object> host, uint32_t index, v8::AccessType type, v8::Local<v8::Value>)
 {
-    $interfaceName* imp =  ${v8InterfaceName}::toNative(host);
+    $implClassName* imp =  ${v8ClassName}::toNative(host);
     return BindingSecurity::shouldAllowAccessToFrame(imp->frame(), DoNotReportSecurityError);
 }
 
 END
     $implementation{nameSpaceInternal}->add(<<END);
 bool namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8::AccessType type, v8::Local<v8::Value>)
 {
-    $interfaceName* imp =  ${v8InterfaceName}::toNative(host);
+    $implClassName* imp =  ${v8ClassName}::toNative(host);
     return BindingSecurity::shouldAllowAccessToFrame(imp->frame(), DoNotReportSecurityError);
 }
 
 END
 }
 
 sub GetNativeTypeForConversions
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
-    $interfaceName = GetSVGTypeNeedingTearOff($interfaceName) if IsSVGTypeNeedingTearOff($interfaceName);
-    return $interfaceName;
+    my $implClassName = GetImplClassName($interface);
+    $implClassName = GetSVGTypeNeedingTearOff($interface->name) if IsSVGTypeNeedingTearOff($interface->name);
+    return $implClassName;
 }
 
 # See http://refspecs.linux-foundation.org/cxxabi-1.83.html.
 sub GetGnuVTableRefForInterface
 {
     my $interface = shift;
     my $vtableName = GetGnuVTableNameForInterface($interface);
     if (!$vtableName) {
         return "0";
     }
@@ skipping 100 matching lines @@
 {
     my $interface = shift;
     return $interface->extendedAttributes->{"SkipVTableValidation"};
 }
 
 sub GenerateFunctionCallString
 {
     my $function = shift;
     my $numberOfParameters = shift;
     my $indent = shift;
-    my $interfaceName = shift;
+    my $interface = shift;
     my $forMainWorldSuffix = shift;
     my %replacements = @_;
 
+    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
     my $name = $function->signature->name;
     my $returnType = $function->signature->type;
     my $nativeReturnType = GetNativeType($returnType, 0);
     my $code = "";
 
     my $isSVGTearOffType = (IsSVGTypeNeedingTearOff($returnType) and not $interfaceName =~ /List$/);
     $nativeReturnType = GetSVGWrappedTypeNeedingTearOff($returnType) if $isSVGTearOffType;
 
     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) {
         AddInterfaceToImplIncludes($implementedBy);
         unshift(@arguments, "imp") if !$function->isStatic;
         $functionName = "${implementedBy}::${name}";
     } elsif ($function->isStatic) {
-        $functionName = "${interfaceName}::${name}";
+        $functionName = "${implClassName}::${name}";
     } else {
         $functionName = "imp->${name}";
     }
 
     my $callWith = $function->signature->extendedAttributes->{"CallWith"};
     my ($callWithArgs, $subCode) = GenerateCallWith($callWith, $indent, 0, $function);
     $code .= $subCode;
     unshift(@arguments, @$callWithArgs);
     $index += @$callWithArgs;
     $numberOfParameters += @$callWithArgs;
@@ skipping 149 matching lines @@
     return "DOMTimeStamp" if $type eq "DOMTimeStamp";
     return "double" if $type eq "Date";
     return "ScriptValue" if $type eq "any";
     return "Dictionary" if $type eq "Dictionary";
 
     return "RefPtr<DOMStringList>" if $type eq "DOMStringList";
     return "RefPtr<MediaQueryListListener>" if $type eq "MediaQueryListListener";
     return "RefPtr<NodeFilter>" if $type eq "NodeFilter";
     return "RefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
     return "RefPtr<XPathNSResolver>" if $type eq "XPathNSResolver";
+
+    # We need to check [ImplementedBy] extended attribute for wrapper types.
+    if (IsWrapperType($type)) {
+        my $interface = ParseInterface($type);
+        my $implClassName = GetImplClassName($interface);
+        return $isParameter ? "${implClassName}*" : "RefPtr<${implClassName}>";
+    }
     return "RefPtr<${type}>" if IsRefPtrType($type) and not $isParameter;
 
     my $arrayType = GetArrayType($type);
     my $sequenceType = GetSequenceType($type);
     my $arrayOrSequenceType = $arrayType || $sequenceType;
 
     if ($arrayOrSequenceType) {
         my $nativeType = GetNativeType($arrayOrSequenceType);
         $nativeType .= " " if ($nativeType =~ />$/);
         return "Vector<${nativeType}>";
@@ skipping 208 matching lines @@
     'DOMString' => 1,
     'DOMTimeStamp' => 1,
     'Date' => 1,
     'Dictionary' => 1,
     'EventListener' => 1,
     # FIXME: When EventTarget is an interface and not a mixin, fix this so that
     # EventTarget is treated as a wrapper type.
     'EventTarget' => 1,
     'JSObject' => 1,
     'MediaQueryListListener' => 1,
+    'MessagePortArray' => 1,
     'NodeFilter' => 1,
     'SerializedScriptValue' => 1,
     'any' => 1,
     'boolean' => 1,
     'double' => 1,
     'float' => 1,
     'int' => 1,
     'long long' => 1,
     'long' => 1,
     'short' => 1,
     'unsigned int' => 1,
     'unsigned long long' => 1,
     'unsigned long' => 1,
-    'unsigned short' => 1
+    'unsigned short' => 1,
+    'void' => 1
 );
 
 
 sub IsWrapperType
 {
     my $type = shift;
-    # FIXME: Should this return false for Sequence and Array types?
+    return 0 if GetArrayType($type);
+    return 0 if GetSequenceType($type);
     return 0 if IsEnumType($type);
     return !($non_wrapper_types{$type});
 }
 
 sub IsCallbackInterface
 {
     my $type = shift;
     return 0 unless IsWrapperType($type);
-    # FIXME: Those checks for Sequence and Array types should probably
-    # be moved to IsWrapperType().
-    return 0 if GetArrayType($type);
-    return 0 if GetSequenceType($type);
 
     my $idlFile = IDLFileForInterface($type)
         or die("Could NOT find IDL file for interface \"$type\"!\n");
 
     open FILE, "<", $idlFile;
     my @lines = <FILE>;
     close FILE;
 
     my $fileContents = join('', @lines);
     return ($fileContents =~ /callback\s+interface\s+(\w+)/gs);
@@ skipping 229 matching lines @@
     if ($signature->extendedAttributes->{"EnabledPerContext"} && $signature->extendedAttributes->{"EnabledPerContext"} ne "VALUE_IS_MISSING") {
         return "ContextFeatures::" . ToMethodName($signature->extendedAttributes->{"EnabledPerContext"}) . "Enabled";
     }
 
     # Or it fallbacks to the attribute name if the parameter value is missing.
     return "ContextFeatures::" . ToMethodName($signature->name) . "Enabled";
 }
 
 sub GetPassRefPtrType
 {
-    my $v8InterfaceName = shift;
+    my $v8ClassName = shift;
 
-    my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
-    return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
+    my $angleBracketSpace = $v8ClassName =~ />$/ ? " " : "";
+    return "PassRefPtr<${v8ClassName}${angleBracketSpace}>";
 }
 
 sub UpdateFile
 {
     my $fileName = shift;
     my $contents = shift;
 
     open FH, "> $fileName" or die "Couldn't open $fileName: $!\n";
     print FH $contents;
     close FH;
@@ skipping 422 matching lines @@
         map { $conditions{$_} = 1 } split('\\' . $operator, $conditional);
         return "ENABLE(" . join(") $operator$operator ENABLE(", sort keys %conditions) . ")";
     } else {
         return "ENABLE(" . $conditional . ")";
     }
 }
 
 sub GenerateCompileTimeCheckForEnumsIfNeeded
 {
     my $interface = shift;
-    my $interfaceName = $interface->name;
+    my $implClassName = GetImplClassName($interface);
     my @checks = ();
     # If necessary, check that all constants are available as enums with the same value.
     if (!$interface->extendedAttributes->{"DoNotCheckConstants"} && @{$interface->constants}) {
         push(@checks, "\n");
         foreach my $constant (@{$interface->constants}) {
             my $reflect = $constant->extendedAttributes->{"Reflect"};
             my $name = $reflect ? $reflect : $constant->name;
             my $value = $constant->value;
             my $conditionalString = GenerateConditionalString($constant);
             push(@checks, "#if ${conditionalString}\n") if $conditionalString;
 
             if ($constant->extendedAttributes->{"ImplementedBy"}) {
-                push(@checks, "COMPILE_ASSERT($value == " . $constant->extendedAttributes->{"ImplementedBy"} . "::$name, ${interfaceName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
+                push(@checks, "COMPILE_ASSERT($value == " . $constant->extendedAttributes->{"ImplementedBy"} . "::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             } else {
-                push(@checks, "COMPILE_ASSERT($value == ${interfaceName}::$name, ${interfaceName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
+                push(@checks, "COMPILE_ASSERT($value == ${implClassName}::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             }
 
             push(@checks, "#endif\n") if $conditionalString;
         }
         push(@checks, "\n");
     }
     return @checks;
 }
 
 sub ExtendedAttributeContains
@@ skipping 45 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;