Rename DOMWindow interface to Window

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 297 matching lines @@
     my $filename = IDLFileForInterface($interfaceName)
         or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
 
     print "  |  |>  Parsing parent IDL \"$filename\" for interface \"$interfaceName\"\n" if $verbose;
 
     # Step #2: Parse the found IDL file (in quiet mode).
     my $parser = IDLParser->new(1);
     my $document = $parser->Parse($filename, $defines, $preprocessor);
 
     foreach my $interface (@{$document->interfaces}) {
-        if ($interface->name eq $interfaceName) {
+        if ($interface->name eq $interfaceName or $interface->isPartial) {
             $cachedInterfaces->{$interfaceName} = $interface;
             return $interface;
         }
     }
 
     die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 sub GenerateInterface
 {
@@ skipping 355 matching lines @@
     }
 
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         $header{classPublic}->add("    static ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object>);\n");
     }
 
     if (InheritsExtendedAttribute($interface, "EventTarget")) {
         $header{classPublic}->add("    static EventTarget* toEventTarget(v8::Handle<v8::Object>);\n");
     }
 
-    if ($interfaceName eq "DOMWindow") {
+    if ($interfaceName eq "Window") {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::ObjectTemplate> GetShadowObjectTemplate(v8::Isolate*, WrapperWorldType);
 END
     }
 
     my @enabledPerContextFunctions;
     foreach my $function (@{$interface->functions}) {
         my $name = $function->name;
         next if $name eq "";
         my $attrExt = $function->extendedAttributes;
@@ skipping 40 matching lines @@
         }
         if ($attrExt->{"EnabledPerContext"}) {
             push(@enabledPerContextAttributes, $attribute);
         }
     }
 
     GenerateHeaderNamedAndIndexedPropertyAccessors($interface);
     GenerateHeaderLegacyCall($interface);
     GenerateHeaderCustomInternalFieldIndices($interface);
 
-    if ($interface->name eq "DOMWindow") {
+    if ($interface->name eq "Window") {
         $header{classPublic}->add(<<END);
     static bool namedSecurityCheckCustom(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8::AccessType, v8::Local<v8::Value> data);
     static bool indexedSecurityCheckCustom(v8::Local<v8::Object> host, uint32_t index, v8::AccessType, v8::Local<v8::Value> data);
 END
     }
 
     if (@enabledPerContextAttributes) {
         $header{classPublic}->add(<<END);
     static void installPerContextProperties(v8::Handle<v8::Object>, ${nativeType}*, v8::Isolate*);
 END
@@ skipping 346 matching lines @@
     my $interface = shift;
     return "V8" . $interface->name;
 }
 
 sub GetImplName
 {
     my $interfaceOrSignature = shift;
     return $interfaceOrSignature->extendedAttributes->{"ImplementedAs"} || $interfaceOrSignature->name;
 }
 
+sub GetImplNameFromImplementedBy
+{
+    my $implementedBy = shift;
+
+    my $interface = ParseInterface($implementedBy);
+    return $interface->extendedAttributes->{"ImplementedAs"} || $implementedBy;
+}
+
 sub GenerateDomainSafeFunctionGetter
 {
     my $function = shift;
     my $interface = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $funcName = $function->name;
 
     my $functionLength = GetFunctionLength($function);
@@ skipping 229 matching lines @@
     $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") {
+        if ($interfaceName eq "Window") {
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.Holder();
 END
         } else {
             # perform lookup first
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return;
 END
@@ skipping 55 matching lines @@
 
     my $returnType = $attribute->signature->type;
     my $getterString;
 
     if ($getterStringUsesImp) {
         my ($functionName, @arguments) = GetterExpression($interfaceName, $attribute);
         push(@arguments, "isNull") if $isNullable;
         push(@arguments, "ec") if $useExceptions;
         if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
             my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
-            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
+            my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
+            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
             unshift(@arguments, "imp") if !$attribute->isStatic;
-            $functionName = "${implementedBy}::${functionName}";
+            $functionName = "${implementedByImplName}::${functionName}";
         } elsif ($attribute->isStatic) {
             $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";
     }
 
     my $expression;
-    if ($attribute->signature->type eq "EventListener" && $interface->name eq "DOMWindow") {
+    if ($attribute->signature->type eq "EventListener" && $interface->name eq "Window") {
         $code .= "    if (!imp->document())\n";
         $code .= "        return;\n";
     }
 
     if ($useExceptions || $isNullable) {
         if ($nativeType =~ /^V8StringResource/) {
             $code .= "    " . ConvertToV8StringResource($attribute->signature, $nativeType, "v", $getterString) . ";\n";
         } else {
             $code .= "    $nativeType v = $getterString;\n";
         }
@@ skipping 155 matching lines @@
     return 0 if IsDOMNodeType($returnType);
 
     # To avoid adding a reference to itself.
     # FIXME: Introduce [DoNotKeepAttributeAliveForGC] and remove this hack
     # depending on the attribute name.
     return 0 if $attrName eq "self";
 
     # FIXME: Remove these hard-coded hacks.
     return 0 if $returnType eq "EventTarget";
     return 0 if $returnType eq "SerializedScriptValue";
-    return 0 if $returnType eq "DOMWindow";
+    return 0 if $returnType eq "Window";
     return 0 if $returnType =~ /SVG/;
     return 0 if $returnType =~ /HTML/;
 
     return 1;
 }
 
 sub GenerateReplaceableAttrSetterCallback
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
@@ skipping 169 matching lines @@
 
         if (!$attribute->isStatic) {
             $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
     my $nativeType = GetNativeTypeFromSignature($attribute->signature, 0);
     if ($attribute->signature->type eq "EventListener") {
-        if ($interface->name eq "DOMWindow") {
+        if ($interface->name eq "Window") {
             $code .= "    if (!imp->document())\n";
             $code .= "        return;\n";
         }
     } else {
         my $value = JSValueToNative($attribute->signature->type, $attribute->signature->extendedAttributes, "value", "info.GetIsolate()");
         my $arrayType = GetArrayType($nativeType);
 
         if ($nativeType =~ /^V8StringResource/) {
             $code .= "    " . ConvertToV8StringResource($attribute->signature, $nativeType, "v", $value) . "\n";
         } elsif ($arrayType) {
@@ skipping 39 matching lines @@
         $code .= "    *imp = $expression;\n";
     } else {
         if ($attribute->signature->type eq "EventListener") {
             my $implSetterFunctionName = FirstLetterToUpperCase($attrName);
             AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
             if (!InheritsInterface($interface, "Node")) {
                 my $attrImplName = GetImplName($attribute->signature);
                 $code .= "    transferHiddenDependency(info.Holder(), imp->${attrImplName}(isolatedWorldForIsolate(info.GetIsolate())), value, ${v8ClassName}::eventListenerCacheIndex, info.GetIsolate());\n";
             }
             AddToImplIncludes("bindings/v8/V8EventListenerList.h");
-            if (($interfaceName eq "DOMWindow" or $interfaceName eq "WorkerContext") and $attribute->signature->name eq "onerror") {
+            if (($interfaceName eq "Window" or $interfaceName eq "WorkerContext") and $attribute->signature->name eq "onerror") {
                 AddToImplIncludes("bindings/v8/V8ErrorHandler.h");
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8ErrorHandler>(value, true), isolatedWorldForIsolate(info.GetIsolate()));\n";
             } else {
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::getEventListener(value, true, ListenerFindOrCreate), isolatedWorldForIsolate(info.GetIsolate()));\n";
             }
         } else {
             my ($functionName, @arguments) = SetterExpression($interfaceName, $attribute);
             push(@arguments, $expression);
             push(@arguments, "ec") if $useExceptions;
             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
-                AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
+                my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
+                AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
                 unshift(@arguments, "imp") if !$attribute->isStatic;
-                $functionName = "${implementedBy}::${functionName}";
+                $functionName = "${implementedByImplName}::${functionName}";
             } elsif ($attribute->isStatic) {
                 $functionName = "${implClassName}::${functionName}";
             } else {
                 $functionName = "imp->${functionName}";
             }
             my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"SetterCallWith"} || $attribute->signature->extendedAttributes->{"CallWith"}, "    ", 1);
             $code .= $subCode;
             unshift(@arguments, @$arg);
             $code .= "    ${functionName}(" . join(", ", @arguments) . ");\n";
         }
@@ skipping 1087 matching lines @@
     my $function = shift;
 
     my $interfaceName = $interface->name;
     my $attrExt = $function->extendedAttributes;
     return 0 if $attrExt->{"Unforgeable"};
     return 0 if $function->isStatic;
     return 0 if $attrExt->{"EnabledAtRuntime"};
     return 0 if $attrExt->{"EnabledPerContext"};
     return 0 if RequiresCustomSignature($function);
     return 0 if $attrExt->{"DoNotCheckSignature"};
-    return 0 if ($attrExt->{"DoNotCheckSecurity"} && ($interface->extendedAttributes->{"CheckSecurity"} || $interfaceName eq "DOMWindow"));
+    return 0 if ($attrExt->{"DoNotCheckSecurity"} && ($interface->extendedAttributes->{"CheckSecurity"} || $interfaceName eq "Window"));
     return 0 if $attrExt->{"NotEnumerable"};
     return 0 if $attrExt->{"ReadOnly"};
     return 1;
 }
 
 sub GenerateNonStandardFunction
 {
     my $interface = shift;
     my $function = shift;
     my $code = "";
@@ skipping 160 matching lines @@
     my $indexedEnumeratorFunction = $indexedGetterFunction;
     $indexedEnumeratorFunction = 0 if $indexedGetterFunction && $indexedGetterFunction->extendedAttributes->{"NotEnumerable"};
 
     # FIXME: Support generated named query bindings.
     my $indexedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
     my $hasQuery = $indexedQueryFunction || $indexedEnumeratorFunction;
 
     my $setOn = "Instance";
 
-    # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
+    # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on Window
     # 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
+    # get implementation straight out of the Window prototype regardless of what prototype is actually set
     # on the object.
-    if ($interfaceName eq "DOMWindow") {
+    if ($interfaceName eq "Window") {
         $setOn = "Prototype";
     }
 
     my $code = "";
     if ($indexedGetterFunction || $indexedSetterFunction || $indexedDeleterFunction || $indexedEnumeratorFunction || $hasQuery) {
         $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8ClassName}::indexedPropertyGetter";
         $code .= $indexedSetterFunction ? ", ${v8ClassName}::indexedPropertySetter" : ", 0";
         $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
         $code .= $indexedDeleterFunction ? ", ${v8ClassName}::indexedPropertyDeleter" : ", 0";
         $code .= ", nodeCollectionIndexedPropertyEnumerator<${implClassName}>" if $indexedEnumeratorFunction;
@@ skipping 135 matching lines @@
 
     # FIXME: Support generated named query bindings.
     my $namedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
     my $hasQuery = $namedQueryFunction || $namedEnumeratorFunction;
 
     my $subCode = "";
     if ($namedGetterFunction || $namedSetterFunction || $namedDeleterFunction || $namedEnumeratorFunction || $hasQuery) {
         my $setOn = "Instance";
 
-        # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
+        # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on Window
         # 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
+        # get implementation straight out of the Window prototype regardless of what prototype is actually set
         # on the object.
-        if ($interfaceName eq "DOMWindow") {
+        if ($interfaceName eq "Window") {
             $setOn = "Prototype";
         }
 
         $subCode .= "    desc->${setOn}Template()->SetNamedPropertyHandler(";
         $subCode .= $namedGetterFunction ? "${v8ClassName}::namedPropertyGetter, " : "0, ";
         $subCode .= $namedSetterFunction ? "${v8ClassName}::namedPropertySetter, " : "0, ";
         $subCode .= $hasQuery ? "${v8ClassName}::namedPropertyQuery, " : "0, ";
         $subCode .= $hasDeleter ? "${v8ClassName}::namedPropertyDeleter, " : "0, ";
         $subCode .= $namedEnumeratorFunction ? "${v8ClassName}::namedPropertyEnumerator" : "0";
         $subCode .= ");\n";
@@ skipping 376 matching lines @@
         my $attrExt = $attribute->signature->extendedAttributes;
 
         # Generate special code for the constructor attributes.
         if ($attrType =~ /Constructor$/) {
             if (!HasCustomGetter($attrExt)) {
                 $hasConstructors = 1;
             }
             next;
         }
 
-        if ($attrType eq "EventListener" && $interfaceName eq "DOMWindow") {
+        if ($attrType eq "EventListener" && $interfaceName eq "Window") {
             $attrExt->{"OnProto"} = 1;
         }
 
         if ($attrType eq "SerializedScriptValue") {
             AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         }
 
         GenerateNormalAttrGetter($attribute, $interface, "");
         GenerateNormalAttrGetterCallback($attribute, $interface, "");
         if ($attrExt->{"PerWorldBindings"}) {
@@ skipping 18 matching lines @@
 
     if ($hasConstructors || $hasReplaceable) {
         GenerateReplaceableAttrSetter($interface);
         GenerateReplaceableAttrSetterCallback($interface);
     }
 
     if (NeedsOpaqueRootForGC($interface)) {
         GenerateOpaqueRootForGC($interface);
     }
 
-    if ($interface->extendedAttributes->{"CheckSecurity"} && $interface->name ne "DOMWindow") {
+    if ($interface->extendedAttributes->{"CheckSecurity"} && $interface->name ne "Window") {
         GenerateSecurityCheckFunctions($interface);
     }
 
     if (IsConstructorTemplate($interface, "TypedArray")) {
         my ($nativeType, $arrayType) = GetNativeTypeOfTypedArray($interface);
         $implementation{nameSpaceWebCore}->add(<<END);
 v8::Handle<v8::Object> wrap($implClassName* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
     v8::Handle<v8::Object> wrapper = ${v8ClassName}::createWrapper(impl, creationContext, isolate);
@@ skipping 48 matching lines @@
         }
     }
 
     if ($needsDomainSafeFunctionSetter) {
         GenerateDomainSafeFunctionSetter($interface);
     }
 
     # Attributes
     my $attributes = $interface->attributes;
 
-    # For the DOMWindow interface we partition the attributes into the
+    # For the Window 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;
     my @enabledPerContextAttributes;
     my @normalAttributes;
     foreach my $attribute (@$attributes) {
 
-        if ($interfaceName eq "DOMWindow" && $attribute->signature->extendedAttributes->{"Unforgeable"}) {
+        if ($interfaceName eq "Window" && $attribute->signature->extendedAttributes->{"Unforgeable"}) {
             push(@disallowsShadowing, $attribute);
         } elsif ($attribute->signature->extendedAttributes->{"EnabledAtRuntime"} || $attribute->signature->extendedAttributes->{"EnabledPerContext"}) {
             if ($attribute->signature->extendedAttributes->{"EnabledPerContext"}) {
                 push(@enabledPerContextAttributes, $attribute);
             }
             if ($attribute->signature->extendedAttributes->{"EnabledAtRuntime"}) {
                 push(@enabledAtRuntimeAttributes, $attribute);
             }
         } else {
             push(@normalAttributes, $attribute);
@@ skipping 58 matching lines @@
     if (@{$interface->constants}) {
         $has_constants = 1;
         $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) {
-            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
+            my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
+            AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
             push(@constantsEnabledAtRuntime, $constant);
         } else {
             my $conditionalString = GenerateConditionalString($constant);
             $code .= "#if ${conditionalString}\n" if $conditionalString;
             # If the value we're dealing with is a hex number, preprocess it into a signed integer
             # here, rather than running static_cast<signed int> in the generated code.
             if (substr($value, 0, 2) eq "0x") {
               $value = unpack('i', pack('I', hex($value)));
@@ skipping 19 matching lines @@
             GenerateEventConstructor($interface);
         } elsif (IsConstructorTemplate($interface, "TypedArray")) {
             GenerateTypedArrayConstructor($interface);
         }
     }
     if (IsConstructable($interface)) {
         GenerateConstructorCallback($interface);
     }
 
     my $access_check = "";
-    if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "DOMWindow") {
+    if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "Window") {
         $access_check = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(&${v8ClassName}::info));";
     }
 
-    # For the DOMWindow interface, generate the shadow object template
+    # For the Window interface, generate the shadow object template
     # configuration method.
-    if ($interfaceName eq "DOMWindow") {
+    if ($interfaceName eq "Window") {
         $implementation{nameSpaceWebCore}->add(<<END);
 static void ConfigureShadowObjectTemplate(v8::Handle<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);
+    templ->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(&V8Window::info));
+    templ->SetInternalFieldCount(V8Window::internalFieldCount);
 }
 END
     }
 
     if (!$parentClassTemplate) {
         $parentClassTemplate = "v8::Local<v8::FunctionTemplate>()";
     }
 
     # Generate the template configuration method
     $code =  <<END;
@@ skipping 111 matching lines @@
 
     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, ${v8ClassName}Consts, WTF_ARRAY_LENGTH(${v8ClassName}Consts), isolate);
 END
     }
 
     # Special cases
-    if ($interfaceName eq "DOMWindow") {
+    if ($interfaceName eq "Window") {
         $code .= <<END;
 
-    proto->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
+    proto->SetInternalFieldCount(V8Window::internalFieldCount);
     desc->SetHiddenPrototype(true);
-    instance->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
+    instance->SetInternalFieldCount(V8Window::internalFieldCount);
     // Set access check callbacks, but turned off initially.
     // When a context is detached from a frame, turn on the access check.
     // Turning on checks also invalidates inline caches of the object.
-    instance->SetAccessCheckCallbacks(V8DOMWindow::namedSecurityCheckCustom, V8DOMWindow::indexedSecurityCheckCustom, v8::External::New(&V8DOMWindow::info), false);
+    instance->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(&V8Window::info), false);
 END
     }
     if ($interfaceName eq "HTMLDocument" or $interfaceName eq "DedicatedWorkerContext" or $interfaceName eq "SharedWorkerContext") {
         $code .= <<END;
     desc->SetHiddenPrototype(true);
 END
     }
 
     $code .= <<END;
 
@@ skipping 124 matching lines @@
     if (InheritsExtendedAttribute($interface, "EventTarget")) {
         $implementation{nameSpaceWebCore}->add(<<END);
 EventTarget* ${v8ClassName}::toEventTarget(v8::Handle<v8::Object> object)
 {
     return toNative(object);
 }
 
 END
     }
 
-    if ($interfaceName eq "DOMWindow") {
+    if ($interfaceName eq "Window") {
         $implementation{nameSpaceWebCore}->add(<<END);
-v8::Handle<v8::ObjectTemplate> V8DOMWindow::GetShadowObjectTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
+v8::Handle<v8::ObjectTemplate> V8Window::GetShadowObjectTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     if (currentWorldType == MainWorld) {
-        static v8::Persistent<v8::ObjectTemplate> V8DOMWindowShadowObjectCacheForMainWorld;
-        if (V8DOMWindowShadowObjectCacheForMainWorld.IsEmpty()) {
+        static v8::Persistent<v8::ObjectTemplate> V8WindowShadowObjectCacheForMainWorld;
+        if (V8WindowShadowObjectCacheForMainWorld.IsEmpty()) {
             v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New();
             ConfigureShadowObjectTemplate(templ, isolate, currentWorldType);
-            V8DOMWindowShadowObjectCacheForMainWorld.Reset(isolate, templ);
+            V8WindowShadowObjectCacheForMainWorld.Reset(isolate, templ);
             return templ;
         }
-        return v8::Local<v8::ObjectTemplate>::New(isolate, V8DOMWindowShadowObjectCacheForMainWorld);
+        return v8::Local<v8::ObjectTemplate>::New(isolate, V8WindowShadowObjectCacheForMainWorld);
     } else {
-        static v8::Persistent<v8::ObjectTemplate> V8DOMWindowShadowObjectCacheForNonMainWorld;
-        if (V8DOMWindowShadowObjectCacheForNonMainWorld.IsEmpty()) {
+        static v8::Persistent<v8::ObjectTemplate> V8WindowShadowObjectCacheForNonMainWorld;
+        if (V8WindowShadowObjectCacheForNonMainWorld.IsEmpty()) {
             v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New();
             ConfigureShadowObjectTemplate(templ, isolate, currentWorldType);
-            V8DOMWindowShadowObjectCacheForNonMainWorld.Reset(isolate, templ);
+            V8WindowShadowObjectCacheForNonMainWorld.Reset(isolate, templ);
             return templ;
         }
-        return v8::Local<v8::ObjectTemplate>::New(isolate, V8DOMWindowShadowObjectCacheForNonMainWorld);
+        return v8::Local<v8::ObjectTemplate>::New(isolate, V8WindowShadowObjectCacheForNonMainWorld);
     }
 }
 
 END
     }
 
     GenerateToV8Converters($interface, $v8ClassName, $nativeType);
 
     $implementation{nameSpaceWebCore}->add(<<END);
 void ${v8ClassName}::derefObject(void* object)
@@ skipping 338 matching lines @@
 
     my $isSVGTearOffType = (IsSVGTypeNeedingTearOff($returnType) and not $interfaceName =~ /List$/);
     $nativeReturnType = GetSVGWrappedTypeNeedingTearOff($returnType) if $isSVGTearOffType;
 
     my $index = 0;
 
     my @arguments;
     my $functionName;
     my $implementedBy = $function->extendedAttributes->{"ImplementedBy"};
     if ($implementedBy) {
-        AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedBy));
+        my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
+        AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
         unshift(@arguments, "imp") if !$function->isStatic;
-        $functionName = "${implementedBy}::${name}";
+        $functionName = "${implementedByImplName}::${name}";
     } elsif ($function->isStatic) {
         $functionName = "${implClassName}::${name}";
     } else {
         $functionName = "imp->${name}";
     }
 
     my $callWith = $function->extendedAttributes->{"CallWith"};
     my ($callWithArgs, $subCode) = GenerateCallWith($callWith, $indent, 1, $function);
     $code .= $subCode;
     unshift(@arguments, @$callWithArgs);
@@ skipping 161 matching lines @@
     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";
 
     die "UnionType is not supported" if IsUnionType($type);
 
-    # We need to check [ImplementedBy] extended attribute for wrapper types.
+    # We need to check [ImplementedAs] extended attribute for wrapper types.
     if (IsWrapperType($type)) {
         my $interface = ParseInterface($type);
         my $implClassName = GetImplName($interface);
         return $isParameter ? "${implClassName}*" : "RefPtr<${implClassName}>";
     }
     return "RefPtr<${type}>" if IsRefPtrType($type) and not $isParameter;
 
     my $arrayOrSequenceType = GetArrayOrSequenceType($type);
 
     if ($arrayOrSequenceType) {
@@ skipping 932 matching lines @@
     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, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
+                my $implementedByImplName = GetImplNameFromImplementedBy($constant->extendedAttributes->{"ImplementedBy"});
+                push(@checks, "COMPILE_ASSERT($value == " . $implementedByImplName . "::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             } else {
                 push(@checks, "COMPILE_ASSERT($value == ${implClassName}::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             }
 
             push(@checks, "#endif\n") if $conditionalString;
         }
         push(@checks, "\n");
     }
     return @checks;
 }
@@ skipping 47 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;