Absolutify paths to bindings/v8, bindings/v8/custom/.

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 203 matching lines @@
 void* V8${interfaceName}::opaqueRootForGC(void* object, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
 {
     ASSERT(!wrapper.IsIndependent(isolate));
     ${interfaceName}* impl = static_cast<${interfaceName}*>(object);
 END
     if (GetGenerateIsReachable($interface) eq  "ImplDocument" ||
         GetGenerateIsReachable($interface) eq  "ImplElementRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerRoot" ||
         GetGenerateIsReachable($interface) eq  "ImplOwnerNodeRoot") {
 
-        $implIncludes{"V8GCController.h"} = 1;
+        $implIncludes{"bindings/v8/V8GCController.h"} = 1;
 
         my $methodName;
         $methodName = "document" if (GetGenerateIsReachable($interface) eq "ImplDocument");
         $methodName = "element" if (GetGenerateIsReachable($interface) eq "ImplElementRoot");
         $methodName = "owner" if (GetGenerateIsReachable($interface) eq "ImplOwnerRoot");
         $methodName = "ownerNode" if (GetGenerateIsReachable($interface) eq "ImplOwnerNodeRoot");
 
         $code .= <<END;
     if (Node* owner = impl->${methodName}())
         return V8GCController::opaqueRootForGC(owner, isolate);
@@ skipping 68 matching lines @@
     if (!$hasDependentLifetime) {
         foreach (@{$interface->parents}) {
             my $parent = $_;
             $headerIncludes{"V8${parent}.h"} = 1;
         }
     }
 
     # - Add default header template
     AddToHeader(GenerateHeaderContentHeader($interface));
 
+    $headerIncludes{"bindings/v8/WrapperTypeInfo.h"} = 1;
+    $headerIncludes{"bindings/v8/V8Binding.h"} = 1;
+    $headerIncludes{"bindings/v8/V8DOMWrapper.h"} = 1;
+    $headerIncludes{"v8.h"} = 1;
+    $headerIncludes{"wtf/HashMap.h"} = 1;
     $headerIncludes{"wtf/text/StringHash.h"} = 1;
-    $headerIncludes{"WrapperTypeInfo.h"} = 1;
-    $headerIncludes{"V8Binding.h"} = 1;
-    $headerIncludes{"V8DOMWrapper.h"} = 1;
-    $headerIncludes{"wtf/HashMap.h"} = 1;
-    $headerIncludes{"v8.h"} = 1;
 
     my $headerClassInclude = GetHeaderClassInclude($interfaceName);
     $headerIncludes{$headerClassInclude} = 1 if $headerClassInclude ne "";
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     foreach my $headerInclude (sort keys(%headerIncludes)) {
         if ($headerInclude =~ /wtf|v8\.h/) {
             AddToHeader("#include \<${headerInclude}\>\n");
         } else {
@@ skipping 655 matching lines @@
 }
 
 sub GenerateActivityLogging
 {
     my $accessType = shift;
     my $interface = shift;
     my $propertyName = shift;
 
     my $visibleInterfaceName = $codeGenerator->GetVisibleInterfaceName($interface);
 
-    AddToImplIncludes("V8Binding.h");
-    AddToImplIncludes("V8DOMActivityLogger.h");
+    AddToImplIncludes("bindings/v8/V8Binding.h");
+    AddToImplIncludes("bindings/v8/V8DOMActivityLogger.h");
     AddToImplIncludes("wtf/Vector.h");
 
     my $code = "";
     if ($accessType eq "Method") {
         $code .= <<END;
     V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
         contextData->activityLogger()->log("${visibleInterfaceName}.${propertyName}", args.Length(), loggerArgs.data(), "${accessType}");
     }
@@ skipping 562 matching lines @@
     if ($useExceptions) {
         AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($interfaceName eq "SVGNumber") {
         $code .= "    *imp = $expression;\n";
     } else {
         if ($attribute->signature->type eq "EventListener") {
             my $implSetterFunctionName = $codeGenerator->WK_ucfirst($attrName);
-            AddToImplIncludes("V8AbstractEventListener.h");
+            AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
             if (!$codeGenerator->InheritsInterface($interface, "Node")) {
                 $code .= "    transferHiddenDependency(info.Holder(), imp->$attrName(), value, ${v8InterfaceName}::eventListenerCacheIndex, info.GetIsolate());\n";
             }
-            AddToImplIncludes("V8EventListenerList.h");
+            AddToImplIncludes("bindings/v8/V8EventListenerList.h");
             if ($interfaceName eq "WorkerContext" and $attribute->signature->name eq "onerror") {
-                AddToImplIncludes("V8WorkerContextErrorHandler.h");
+                AddToImplIncludes("bindings/v8/V8WorkerContextErrorHandler.h");
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8WorkerContextErrorHandler>(value, true)";
             } elsif ($interfaceName eq "DOMWindow" and $attribute->signature->name eq "onerror") {
                 AddToImplIncludes("V8WindowErrorHandler.h");
                 $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 {
@@ skipping 236 matching lines @@
     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("V8EventListenerList.h");
+        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());
 END
         if (!$codeGenerator->InheritsInterface($interface, "Node")) {
             $code .= <<END;
         ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], V8${interfaceName}::eventListenerCacheIndex, args.GetIsolate());
 END
         }
         $code .= <<END;
     }
     return v8Undefined();
 }
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         AddToImplContentInternals($code);
         return;
     }
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($name eq "set" and $interface->extendedAttributes->{"TypedArray"}) {
-        AddToImplIncludes("V8ArrayBufferViewCustom.h");
+        AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
     return setWebGLArrayHelper<$interfaceName, ${v8InterfaceName}>(args);
 }
 
 END
         AddToImplContentInternals($code);
         return;
     }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
@@ skipping 87 matching lines @@
         $code .= $indent . "ScriptState& state = *currentState;\n";
         push(@callWithArgs, "&state");
     }
     if ($codeGenerator->ExtendedAttributeContains($callWith, "ScriptExecutionContext")) {
         $code .= $indent . "ScriptExecutionContext* scriptContext = getScriptExecutionContext();\n";
         push(@callWithArgs, "scriptContext");
     }
     if ($function and $codeGenerator->ExtendedAttributeContains($callWith, "ScriptArguments")) {
         $code .= $indent . "RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, " . @{$function->parameters} . "));\n";
         push(@callWithArgs, "scriptArguments.release()");
-        AddToImplIncludes("ScriptArguments.h");
-        AddToImplIncludes("ScriptCallStackFactory.h");
+        AddToImplIncludes("bindings/v8/ScriptCallStackFactory.h");
+        AddToImplIncludes("core/inspector/ScriptArguments.h");
     }
     return ([@callWithArgs], $code);
 }
 
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
 
     my $numMandatoryParams = 0;
@@ skipping 83 matching lines @@
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ${v8InterfaceName}::create(args[$paramIndex], getScriptExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
                 my $nativeValue = "${parameterName}NativeValue";
                 my $paramType = $parameter->type;
                 $parameterCheckString .= "    $paramType $parameterName = 0;\n";
                 $parameterCheckString .= "    V8TRYCATCH(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$paramType>($nativeValue);\n";
         } elsif ($parameter->type eq "SerializedScriptValue") {
-            AddToImplIncludes("SerializedScriptValue.h");
+            AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
             my $useTransferList = 0;
             my $transferListName = "";
             my $TransferListName = "";
             if ($parameter->extendedAttributes->{"TransferList"}) {
                 $transferListName = $parameter->extendedAttributes->{"TransferList"};
                 push(@paramTransferListNames, $transferListName);
 
                 my @allParameterNames = ();
                 foreach my $parameter (@{$function->parameters}) {
                     push(@allParameterNames, $parameter->name);
@@ skipping 282 matching lines @@
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 sub GenerateEventConstructor
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
 
-    AddToImplIncludes("Dictionary.h");
+    AddToImplIncludes("bindings/v8/Dictionary.h");
     AddToImplContentInternals(<<END);
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
     ${interfaceName}Init eventInit;
     if (args.Length() >= 2) {
         V8TRYCATCH(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
@@ skipping 38 matching lines @@
 END
     AddToImplContent($code);
 }
 
 sub GenerateTypedArrayConstructor
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $viewType = GetTypeNameOfExternalTypedArray($interface);
     my $type = $interface->extendedAttributes->{"TypedArray"};
-    AddToImplIncludes("V8ArrayBufferViewCustom.h");
+    AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
 
     AddToImplContentInternals(<<END);
 static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
 {
     return constructWebGLArray<$interfaceName, V8${interfaceName}, $type>(args, &V8${interfaceName}::info, $viewType);
 }
 
 END
 }
 
@@ skipping 405 matching lines @@
     # FIXME: Find a way to not have to special-case HTMLOptionsCollection.
     if ($interfaceName eq "HTMLOptionsCollection") {
         $hasEnumerator = 1;
         $hasIndexedGetter = 1;
     }
 
     if (!$hasIndexedGetter) {
         return "";
     }
 
-    AddToImplIncludes("V8Collection.h");
+    AddToImplIncludes("bindings/v8/V8Collection.h");
 
     if (!$indexer) {
         $indexer = $codeGenerator->FindSuperMethod($interface, "item");
     }
 
     my $indexerType = $indexer ? $indexer->type : 0;
 
     if ($indexerType && !$hasCustomIndexedSetter) {
         $hasEnumerator = 1;
     }
@@ skipping 67 matching lines @@
 
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     if (!$namedPropertyGetter) {
         $namedPropertyGetter = $codeGenerator->FindSuperMethod($interface, "namedItem");
     }
 
     if ($interface->extendedAttributes->{"NamedGetter"}) {
         die "$interfaceName: [NamedGetter] but no namedItem() method." if (!$namedPropertyGetter);
-        AddToImplIncludes("V8Collection.h");
+        AddToImplIncludes("bindings/v8/V8Collection.h");
         my $type = $namedPropertyGetter->type;
         $subCode .= <<END;
     desc->InstanceTemplate()->SetNamedPropertyHandler(${v8InterfaceName}::namedPropertyGetter, 0, 0, 0, 0);
 END
 
         my $code .= <<END;
 v8::Handle<v8::Value> ${v8InterfaceName}::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
         return v8Undefined();
@@ skipping 90 matching lines @@
     my $visibleInterfaceName = $codeGenerator->GetVisibleInterfaceName($interface);
     my $v8InterfaceName = "V8$interfaceName";
     my $nativeType = GetNativeTypeForConversions($interface);
     my $vtableNameGnu = GetGnuVTableNameForInterface($interface);
     my $vtableRefGnu = GetGnuVTableRefForInterface($interface);
     my $vtableRefWin = GetWinVTableRefForInterface($interface);
 
     # - Add default header template
     push(@implContentHeader, GenerateImplementationContentHeader($interface));
 
-    AddToImplIncludes("BindingState.h");
+    AddToImplIncludes("bindings/v8/BindingState.h");
+    AddToImplIncludes("bindings/v8/V8Binding.h");
+    AddToImplIncludes("bindings/v8/V8DOMWrapper.h");
     AddToImplIncludes("core/dom/ContextFeatures.h");
-    AddToImplIncludes("V8Binding.h");
-    AddToImplIncludes("V8DOMWrapper.h");
     AddToImplIncludes("core/page/RuntimeEnabledFeatures.h");
 
     AddIncludesForType($interfaceName);
 
     my $toActiveDOMObject = $codeGenerator->InheritsExtendedAttribute($interface, "ActiveDOMObject") ? "${v8InterfaceName}::toActiveDOMObject" : "0";
     my $toEventTarget = $codeGenerator->InheritsExtendedAttribute($interface, "EventTarget") ? "${v8InterfaceName}::toEventTarget" : "0";
     my $rootForGC = NeedsCustomOpaqueRootForGC($interface) ? "${v8InterfaceName}::opaqueRootForGC" : "0";
 
     # Find the super descriptor.
     my $parentClass = "";
@@ skipping 96 matching lines @@
                 $hasConstructors = 1;
             }
             next;
         }
 
         if ($attrType eq "EventListener" && $interfaceName eq "DOMWindow") {
             $attrExt->{"OnProto"} = 1;
         }
 
         if ($attrType eq "SerializedScriptValue") {
-            AddToImplIncludes("SerializedScriptValue.h");
+            AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         }
 
         GenerateNormalAttrGetter($attribute, $interface, "");
         GenerateNormalAttrGetterCallback($attribute, $interface, "");
         if ($attrExt->{"PerWorldBindings"}) {
             GenerateNormalAttrGetter($attribute, $interface, "ForMainWorld");
             GenerateNormalAttrGetterCallback($attribute, $interface, "ForMainWorld");
         }
         if (!HasCustomSetter($attrExt) && $attrExt->{"Replaceable"}) {
             $hasReplaceable = 1;
@@ skipping 607 matching lines @@
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
 
     # - Add default header template
     AddToHeader(GenerateHeaderContentHeader($interface));
 
     my @unsortedIncludes = ();
-    push(@unsortedIncludes, "#include \"ActiveDOMCallback.h\"");
-    push(@unsortedIncludes, "#include \"DOMWrapperWorld.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/ActiveDOMCallback.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/DOMWrapperWorld.h\"");
+    push(@unsortedIncludes, "#include \"bindings/v8/ScopedPersistent.h\"");
     my $interfaceHeader = $codeGenerator->HeaderFileForInterface($interfaceName);
     push(@unsortedIncludes, "#include \"$interfaceHeader\"");
-    push(@unsortedIncludes, "#include \"ScopedPersistent.h\"");
     push(@unsortedIncludes, "#include <v8.h>");
     push(@unsortedIncludes, "#include <wtf/Forward.h>");
     AddToHeader(join("\n", sort @unsortedIncludes));
     
     AddToHeader("\n\nnamespace WebCore {\n\n");
     AddToHeader("class ScriptExecutionContext;\n\n");
     AddToHeader("class $v8InterfaceName : public $interfaceName, public ActiveDOMCallback {\n");
 
     AddToHeader(<<END);
 public:
@@ skipping 54 matching lines @@
 {
     my $object = shift;
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     # - Add default header template
     push(@implContentHeader, GenerateImplementationContentHeader($interface));
 
     AddToImplIncludes("core/dom/ScriptExecutionContext.h");
-    AddToImplIncludes("V8Binding.h");
-    AddToImplIncludes("V8Callback.h");
+    AddToImplIncludes("bindings/v8/V8Binding.h");
+    AddToImplIncludes("bindings/v8/V8Callback.h");
 
     AddToImplContent("#include <wtf/Assertions.h>\n\n");
     AddToImplContent("namespace WebCore {\n\n");
 
     AddToImplContent(<<END);
 ${v8InterfaceName}::${v8InterfaceName}(v8::Handle<v8::Object> callback, ScriptExecutionContext* context)
     : ActiveDOMCallback(context)
     , m_callback(callback)
     , m_world(DOMWrapperWorld::current())
 {
@@ skipping 90 matching lines @@
 {
     my $interface = shift;
     my $v8InterfaceName = shift;
     my $nativeType = shift;
     my $interfaceName = $interface->name;
 
     if ($interface->extendedAttributes->{"NoWrapperCache"} || $interface->extendedAttributes->{"SuppressToJSObject"}) {
         return;
     }
 
+    AddToImplIncludes("bindings/v8/ScriptController.h");
     AddToImplIncludes("core/page/Frame.h");
-    AddToImplIncludes("ScriptController.h");
 
     my $createWrapperArgumentType = GetPassRefPtrType($nativeType);
     my $baseType = BaseInterfaceName($interface);
 
     my $code = "";
     $code .= <<END;
 
 v8::Handle<v8::Object> ${v8InterfaceName}::createWrapper(${createWrapperArgumentType} impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl.get());
@@ skipping 451 matching lines @@
 
     if ($type eq "DOMString") {
         return $value;
     }
 
     if ($codeGenerator->IsEnumType($type)) {
         return $value;
     }
 
     if ($type eq "SerializedScriptValue") {
-        AddToImplIncludes("SerializedScriptValue.h");
+        AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         return "SerializedScriptValue::create($value, $getIsolate)";
     }
 
     if ($type eq "Dictionary") {
-        AddToImplIncludes("Dictionary.h");
+        AddToImplIncludes("bindings/v8/Dictionary.h");
         return "Dictionary($value, $getIsolate)";
     }
 
     if ($type eq "any") {
-        AddToImplIncludes("ScriptValue.h");
+        AddToImplIncludes("bindings/v8/ScriptValue.h");
         return "ScriptValue($value)";
     }
 
     if ($type eq "NodeFilter") {
         return "toNodeFilter($value)";
     }
 
     if ($type eq "MediaQueryListListener") {
         AddToImplIncludes("core/css/MediaQueryListListener.h");
         return "MediaQueryListListener::create(" . $value . ")";
@@ skipping 23 matching lines @@
 
     AddToImplIncludes("V8${type}.h");
     return "V8${type}::HasInstance($value, $getIsolate, worldType($getIsolate)) ? V8${type}::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
 }
 
 sub GetV8HeaderName
 {
     my $type = shift;
     return "V8Event.h" if $type eq "DOMTimeStamp";
     return "core/dom/EventListener.h" if $type eq "EventListener";
-    return "SerializedScriptValue.h" if $type eq "SerializedScriptValue";
-    return "ScriptValue.h" if $type eq "any";
+    return "bindings/v8/SerializedScriptValue.h" if $type eq "SerializedScriptValue";
+    return "bindings/v8/ScriptValue.h" if $type eq "any";
     return "V8${type}.h";
 }
 
 sub CreateCustomSignature
 {
     my $function = shift;
     my $count = @{$function->parameters};
     my $name = $function->signature->name;
     my $code = "    const int ${name}Argc = ${count};\n" .
       "    v8::Handle<v8::FunctionTemplate> ${name}Argv[${name}Argc] = { ";
@@ skipping 230 matching lines @@
     AddIncludesForType($type);
 
     if (IsDOMNodeType($type) || $type eq "EventTarget") {
       if ($getScriptWrappable) {
           return "toV8Fast${forMainWorldSuffix}($value$getHolderContainerArg$getScriptWrappableArg)";
       }
       return "toV8($value, $getCreationContext, $getIsolate)";
     }
 
     if ($type eq "EventListener") {
-        AddToImplIncludes("V8AbstractEventListener.h");
+        AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
         return "${value} ? v8::Handle<v8::Value>(static_cast<V8AbstractEventListener*>(${value})->getListenerObject(imp->scriptExecutionContext())) : v8::Handle<v8::Value>(v8Null($getIsolate))";
     }
 
     if ($type eq "SerializedScriptValue") {
         AddToImplIncludes("$type.h");
         return "$value ? $value->deserialize() : v8::Handle<v8::Value>(v8Null($getIsolate))";
     }
 
     AddToImplIncludes("wtf/RefCounted.h");
     AddToImplIncludes("wtf/RefPtr.h");
@@ skipping 111 matching lines @@
 
 sub GetPassRefPtrType
 {
     my $v8InterfaceName = shift;
 
     my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
     return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
 }
 
 1;