Use upstream V8Proxy and V8Utilities

webkit/port/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 Google Inc.
 #
 # This file is part of the KDE project
 #
@@ skipping 297 matching lines @@
     push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditional;
 }
 
 
 sub GenerateSetDOMException
 {
   my $indent = shift;
   my $result = "";
 
   $result .= $indent . "if (ec) {\n";
-  $result .= $indent . "    V8Proxy::SetDOMException(ec);\n";
+  $result .= $indent . "    V8Proxy::setDOMException(ec);\n";
   $result .= $indent . "    return v8::Handle<v8::Value>();\n";
   $result .= $indent . "}\n";
 
   return $result;
 }
 
 sub IsNodeSubType
 {
   my $dataNode = shift;
   return 1 if ($dataNode->name eq "Node");
   foreach (@allParents) {
     my $parent = $codeGenerator->StripModule($_);
     return 1 if $parent eq "Node";
   }
   return 0;
 }
 
 sub HolderToNative
 {
   my $dataNode = shift;
   my $implClassName = shift;
   my $classIndex = shift;
 
   if (IsNodeSubType($dataNode)) {
     push(@implContentDecls, <<END);
-    $implClassName* imp = V8Proxy::DOMWrapperToNode<$implClassName>(holder);
+    $implClassName* imp = V8Proxy::convertDOMWrapperToNode<$implClassName>(holder);
 END
 
   } else {
     push(@implContentDecls, <<END);
-    $implClassName* imp = V8Proxy::ToNativeObject<$implClassName>(V8ClassIndex::$classIndex, holder);
+    $implClassName* imp = V8Proxy::convertToNativeObject<$implClassName>(V8ClassIndex::$classIndex, holder);
 END
 
   }
 }
 
 sub GenerateDomainSafeFunctionGetter
 {
   my $function = shift;
   my $dataNode = shift;
   my $classIndex = shift;
   my $implClassName = shift;
 
   my $className = "V8" . $dataNode->name;
   my $funcName = $function->signature->name;
 
   my $signature = "v8::Signature::New(" . $className . "::GetRawTemplate())";
   if ($function->signature->extendedAttributes->{"V8DoNotCheckSignature"}) {
     $signature = "v8::Local<v8::Signature>()";
   }
 
   my $newTemplateString = GenerateNewFunctionTemplate($function, $dataNode, $signature);
 
-  $implIncludes{"v8_proxy.h"} = 1;
+  $implIncludes{"V8Proxy.h"} = 1;
 
   push(@implContentDecls, <<END);
   static v8::Handle<v8::Value> ${funcName}AttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info) {
     INC_STATS(\"DOM.$implClassName.$funcName._get\");
     static v8::Persistent<v8::FunctionTemplate> private_template =
         v8::Persistent<v8::FunctionTemplate>::New($newTemplateString);
-    v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
+    v8::Handle<v8::Object> holder = V8Proxy::lookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
     if (holder.IsEmpty()) {
       // can only reach here by 'object.__proto__.func', and it should passed
       // domain security check already
 
       return private_template->GetFunction();
     }
 END
 
   HolderToNative($dataNode, $implClassName, $classIndex);
 
   push(@implContentDecls, <<END);
-    if (!V8Proxy::CanAccessFrame(imp->frame(), false)) {
+    if (!V8Proxy::canAccessFrame(imp->frame(), false)) {
       static v8::Persistent<v8::FunctionTemplate> shared_template =
         v8::Persistent<v8::FunctionTemplate>::New($newTemplateString);
       return shared_template->GetFunction();
 
     } else {
       return private_template->GetFunction();
     }
   }
 
 END
 }
 
 sub GenerateConstructorGetter
 {
   my $implClassName = shift;
   my $classIndex = shift;
       
   push(@implContentDecls, <<END);
   static v8::Handle<v8::Value> ${implClassName}ConstructorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info) {
     INC_STATS(\"DOM.$implClassName.constructors._get\");
     v8::Handle<v8::Value> data = info.Data();
     ASSERT(data->IsNumber());
     V8ClassIndex::V8WrapperType type = V8ClassIndex::FromInt(data->Int32Value());
 END
 
   if ($classIndex eq "DOMWINDOW") {
     push(@implContentDecls, <<END);
-    DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
+    DOMWindow* window = V8Proxy::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
     Frame* frame = window->frame();
     if (frame) {
       // Get the proxy corresponding to the DOMWindow if possible to
       // make sure that the constructor function is constructed in the
       // context of the DOMWindow and not in the context of the caller.
-      return V8Proxy::retrieve(frame)->GetConstructor(type);
+      return V8Proxy::retrieve(frame)->getConstructor(type);
     }
 END
   }
   
   if ($classIndex eq "WORKERCONTEXT") {
     $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
     push(@implContentDecls, <<END);
     return WorkerContextExecutionProxy::retrieve()->GetConstructor(type);
 END
   } else {
@@ skipping 10 matching lines @@
 sub GenerateNormalAttrGetter
 {
   my $attribute = shift;
   my $dataNode = shift;
   my $classIndex = shift;
   my $implClassName = shift;
 
   my $attrExt = $attribute->signature->extendedAttributes;
 
   my $attrName = $attribute->signature->name;
-  $implIncludes{"v8_proxy.h"} = 1;
+  $implIncludes{"V8Proxy.h"} = 1;
 
   my $attrType = $codeGenerator->StripModule($attribute->signature->type);
   my $attrIsPodType = $codeGenerator->IsPodType($attrType);
   my $nativeType = GetNativeTypeFromSignature($attribute->signature, 0);
   my $isPodType = $codeGenerator->IsPodType($implClassName);
   my $skipContext = 0;
 
 
   if ($isPodType) {
     $implClassName = GetNativeType($implClassName);
@@ skipping 20 matching lines @@
   my $getterStringUsesImp = $implClassName ne "double";
 
   # Getter
   push(@implContentDecls, <<END);
   static v8::Handle<v8::Value> ${attrName}AttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info) {
     INC_STATS(\"DOM.$implClassName.$attrName._get\");
 END
 
   if ($isPodType) {
     push(@implContentDecls, <<END);
-    V8SVGPODTypeWrapper<$implClassName>* imp_wrapper = V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());
+    V8SVGPODTypeWrapper<$implClassName>* imp_wrapper = V8Proxy::convertToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());
     $implClassName imp_instance = *imp_wrapper;
 END
     if ($getterStringUsesImp) {
       push(@implContentDecls, <<END);
     $implClassName* imp = &imp_instance;
 END
     }
 
   } elsif ($attrExt->{"v8OnProto"} || $attrExt->{"V8DisallowShadowing"}) {
     # perform lookup first
     push(@implContentDecls, <<END);
-    v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
+    v8::Handle<v8::Object> holder = V8Proxy::lookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
     if (holder.IsEmpty()) return v8::Undefined();
 END
     HolderToNative($dataNode, $implClassName, $classIndex);
   } else {
     push(@implContentDecls, <<END);
     v8::Handle<v8::Object> holder = info.Holder();
 END
     HolderToNative($dataNode, $implClassName, $classIndex);
   }
 
   # Generate security checks if necessary
   if ($attribute->signature->extendedAttributes->{"CheckNodeSecurity"}) {
-    push(@implContentDecls, "    if (!V8Proxy::CheckNodeSecurity(imp->$attrName())) return v8::Undefined();\n\n"); 
+    push(@implContentDecls, "    if (!V8Proxy::checkNodeSecurity(imp->$attrName())) return v8::Undefined();\n\n"); 
   } elsif ($attribute->signature->extendedAttributes->{"CheckFrameSecurity"}) {
-    push(@implContentDecls, "    if (!V8Proxy::CheckNodeSecurity(imp->contentDocument())) return v8::Undefined();\n\n");
+    push(@implContentDecls, "    if (!V8Proxy::checkNodeSecurity(imp->contentDocument())) return v8::Undefined();\n\n");
   }
 
   my $useExceptions = 1 if @{$attribute->getterExceptions} and !($isPodType); 
   if ($useExceptions) {
     $implIncludes{"ExceptionCode.h"} = 1;
     push(@implContentDecls, "    ExceptionCode ec = 0;\n");
   }
 
   if ($attribute->signature->extendedAttributes->{"v8referenceattr"}) {
     $attrName = $attribute->signature->extendedAttributes->{"v8referenceattr"};
@@ skipping 76 matching lines @@
     my $resultObject = $result;
     if ($attrIsPodType) {
       $resultObject = "wrapper";
     }
     
     push(@implContentDecls, GenerateSVGContextAssignment($implClassName, $resultObject, "    "));
   }
 
   if ($attrIsPodType) {
     my $classIndex = uc($attrType);
-    push(@implContentDecls, "    return V8Proxy::ToV8Object(V8ClassIndex::$classIndex, wrapper);\n");
+    push(@implContentDecls, "    return V8Proxy::convertToV8Object(V8ClassIndex::$classIndex, wrapper);\n");
   } else {
     push(@implContentDecls, "    return " . NativeToJSValue($attribute->signature, $result). ";\n");
   }
   
   push(@implContentDecls, "  }\n\n");  # end of getter 
 }
 
 
 sub GenerateReplaceableAttrSetter
 {
   my $implClassName = shift;
 
-  $implIncludes{"v8_proxy.h"} = 1;
+  $implIncludes{"V8Proxy.h"} = 1;
 
   push(@implContentDecls, 
        "  static void ${attrName}AttrSetter(v8::Local<v8::String> name," . 
        " v8::Local<v8::Value> value, const v8::AccessorInfo& info) {\n");
 
   push(@implContentDecls, "    INC_STATS(\"DOM.$implClassName.$attrName._set\");\n");
 
   push(@implContentDecls, "    v8::Local<v8::String> ${attrName}_string = v8::String::New(\"${attrName}\");\n");
   push(@implContentDecls, "    info.Holder()->Delete(${attrName}_string);\n");
   push(@implContentDecls, "    info.This()->Set(${attrName}_string, value);\n");
   push(@implContentDecls, "  }\n\n");
 }
 
 
 sub GenerateNormalAttrSetter
 {
   my $attribute = shift;
   my $dataNode = shift;
   my $classIndex = shift;
   my $implClassName = shift;
 
   my $attrExt = $attribute->signature->extendedAttributes;
 
-  $implIncludes{"v8_proxy.h"} = 1;
+  $implIncludes{"V8Proxy.h"} = 1;
 
   push(@implContentDecls, 
        "  static void ${attrName}AttrSetter(v8::Local<v8::String> name," . 
        " v8::Local<v8::Value> value, const v8::AccessorInfo& info) {\n");
 
   push(@implContentDecls, "    INC_STATS(\"DOM.$implClassName.$attrName._set\");\n");
 
   my $isPodType = $codeGenerator->IsPodType($implClassName);
 
   if ($isPodType) {
     $implClassName = GetNativeType($implClassName);
     $implIncludes{"V8SVGPODTypeWrapper.h"} = 1;
-    push(@implContentDecls, "    V8SVGPODTypeWrapper<$implClassName>* wrapper = V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());\n");
+    push(@implContentDecls, "    V8SVGPODTypeWrapper<$implClassName>* wrapper = V8Proxy::convertToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());\n");
     push(@implContentDecls, "    $implClassName imp_instance = *wrapper;\n");
     push(@implContentDecls, "    $implClassName* imp = &imp_instance;\n");
 
   } elsif ($attrExt->{"v8OnProto"}) {
     # perform lookup first
     push(@implContentDecls, <<END);
-    v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
+    v8::Handle<v8::Object> holder = V8Proxy::lookupDOMWrapper(V8ClassIndex::$classIndex, info.This());
     if (holder.IsEmpty()) return v8::Undefined();
 END
     HolderToNative($dataNode, $implClassName, $classIndex);
   } else {
     push(@implContentDecls, <<END);
     v8::Handle<v8::Object> holder = info.Holder();
 END
     HolderToNative($dataNode, $implClassName, $classIndex);
   }
 
@@ skipping 22 matching lines @@
   
   if ($implClassName eq "double") {
     push(@implContentDecls, "    *imp = $result;\n");
   } else {
     push(@implContentDecls, "    imp->set" . WK_ucfirst($attrName) . "(" . $result);
     push(@implContentDecls, ", ec") if $useExceptions;
     push(@implContentDecls, ");\n");
   }
 
   if ($useExceptions) {
-    push(@implContentDecls, "    V8Proxy::SetDOMException(ec);\n");
+    push(@implContentDecls, "    V8Proxy::setDOMException(ec);\n");
   }
   
   if ($isPodType) {
-    push(@implContentDecls, "    wrapper->commitChange(*imp, V8Proxy::GetSVGContext(wrapper));\n");
+    push(@implContentDecls, "    wrapper->commitChange(*imp, V8Proxy::svgContext(wrapper));\n");
   } elsif (IsSVGTypeNeedingContextParameter($implClassName)) {
     $implIncludes{"SVGElement.h"} = 1;
     
     my $currentObject = "imp";
     if ($isPodType) {
       $currentObject = "wrapper";
     }
 
-    push(@implContentDecls, "    if (SVGElement* context = V8Proxy::GetSVGContext($currentObject)) {\n");
+    push(@implContentDecls, "    if (SVGElement* context = V8Proxy::svgContext($currentObject)) {\n");
     push(@implContentDecls, "        context->svgAttributeChanged(imp->associatedAttributeName());\n");
     push(@implContentDecls, "    }\n");
   }
 
   push(@implContentDecls, "    return;\n");
   push(@implContentDecls, "  }\n\n");  # end of setter
 }
 
 
 sub GenerateNewFunctionTemplate
@@ skipping 39 matching lines @@
 
   my $numParameters = @{$function->parameters};
 
   if ($function->signature->extendedAttributes->{"RequiresAllArguments"}) {
     push(@implContentDecls,
          "    if (args.Length() < $numParameters) return v8::Undefined();\n");
   }
 
   if ($codeGenerator->IsPodType($implClassName)) {
     my $nativeClassName = GetNativeType($implClassName);
-    push(@implContentDecls, "    V8SVGPODTypeWrapper<$nativeClassName>* imp_wrapper = V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<$nativeClassName> >(V8ClassIndex::$classIndex, args.Holder());\n");
+    push(@implContentDecls, "    V8SVGPODTypeWrapper<$nativeClassName>* imp_wrapper = V8Proxy::convertToNativeObject<V8SVGPODTypeWrapper<$nativeClassName> >(V8ClassIndex::$classIndex, args.Holder());\n");
     push(@implContentDecls, "    $nativeClassName imp_instance = *imp_wrapper;\n");
     push(@implContentDecls, "    $nativeClassName* imp = &imp_instance;\n");
   } else {
     push(@implContentDecls, <<END);
     v8::Handle<v8::Value> holder = args.Holder();
 END
     HolderToNative($dataNode, $implClassName, $classIndex);
   }
 
   # Check domain security if needed
   if (($dataNode->extendedAttributes->{"CheckDomainSecurity"} 
        || $interfaceName eq "DOMWindow")
     && !$function->signature->extendedAttributes->{"DoNotCheckDomainSecurity"}) {
     # We have not find real use cases yet.
     push(@implContentDecls,
-"    if (!V8Proxy::CanAccessFrame(imp->frame(), true)) {\n".
+"    if (!V8Proxy::canAccessFrame(imp->frame(), true)) {\n".
 "      return v8::Undefined();\n" .
 "    }\n"); 
   }
 
 
   if (@{$function->raisesExceptions}) {
     $implIncludes{"ExceptionCode.h"} = 1;
     push(@implContentDecls, "    ExceptionCode ec = 0;\n");
   }
 
@@ skipping 21 matching lines @@
     }
 
     push(@implContentDecls, "    " . GetNativeTypeFromSignature($parameter, 1) . " $parameterName = ");
     push(@implContentDecls, JSValueToNative($parameter, "args[$paramIndex]", 
            BasicTypeCanFailConversion($parameter) ?  "${parameterName}Ok" : undef) . ";\n");
 
     if (TypeCanFailConversion($parameter)) {
       $implIncludes{"ExceptionCode.h"} = 1;
       push(@implContentDecls,
 "    if (!$parameterName" . (BasicTypeCanFailConversion($parameter) ? "Ok" : "") . ") {\n" .
-"      V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);\n" .
+"      V8Proxy::setDOMException(TYPE_MISMATCH_ERR);\n" .
 "      return v8::Handle<v8::Value>();\n" .
 "    }\n");
     }
 
     if ($parameter->extendedAttributes->{"IsIndex"}) {
       $implIncludes{"ExceptionCode.h"} = 1;
       push(@implContentDecls,
 "    if ($parameterName < 0) {\n" .
-"      V8Proxy::SetDOMException(INDEX_SIZE_ERR);\n" .
+"      V8Proxy::setDOMException(INDEX_SIZE_ERR);\n" .
 "      return v8::Handle<v8::Value>();\n" .
 "    }\n");
     }
         
     $paramIndex++;
   }
   
   # Build the function call string.
   my $callString = GenerateFunctionCallString($function, $paramIndex, "    ", $implClassName);
   push(@implContentDecls, "$callString");
@@ skipping 171 matching lines @@
     my $hasLegacyParent = $dataNode->extendedAttributes->{"LegacyParent"};
     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
 
     @allParents = $codeGenerator->FindParentsRecursively($dataNode);
 
     # - Add default header template
     @implContentHeader = split("\r", $headerTemplate);
 
     push(@implFixedHeader,
          "#include \"config.h\"\n" .
-         "#include \"v8_proxy.h\"\n" .
+         "#include \"V8Proxy.h\"\n" .
          "#include \"v8_binding.h\"\n\n" .
          "#undef LOG\n\n");
  
     my $conditionalString;
     if ($conditional) {
         $conditionalString = "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";
         push(@implFixedHeader, "\n#if ${conditionalString}\n\n");
     }
     
     if ($className =~ /^V8SVGAnimated/) {
         AddIncludesForSVGAnimatedType($interfaceName);
     }
 
     $implIncludes{"${className}.h"} = 1;
 
     AddIncludesForType($interfaceName);
-    $implIncludes{"v8_proxy.h"} = 1;
+    $implIncludes{"V8Proxy.h"} = 1;
     
     push(@implContentDecls, "namespace WebCore {\n");
     push(@implContentDecls, "namespace ${interfaceName}Internal {\n\n");
     push(@implContentDecls, "template <typename T> void V8_USE(T) { }\n\n");
 
     my $hasConstructors = 0;
 
     # Generate property accessors for attributes.
     for ($index = 0; $index < @{$dataNode->attributes}; $index++) {
       $attribute = @{$dataNode->attributes}[$index];
@@ skipping 129 matching lines @@
     if ($dataNode->extendedAttributes->{"CheckDomainSecurity"} &&
         !($interfaceName eq "DOMWindow")) {
       $access_check = "instance->SetAccessCheckCallbacks(V8Custom::v8${interfaceName}NamedSecurityCheck, V8Custom::v8${interfaceName}IndexedSecurityCheck, v8::Integer::New(V8ClassIndex::ToInt(V8ClassIndex::${classIndex})));";
     }
 
     # For the DOMWindow interface, generate the shadow object template
     # configuration method.
     if ($implClassName eq "DOMWindow") {
       push(@implContent, <<END);
 static v8::Persistent<v8::ObjectTemplate> ConfigureShadowObjectTemplate(v8::Persistent<v8::ObjectTemplate> templ) {
-  BatchConfigureAttributes(templ,
+  batchConfigureAttributes(templ,
                            v8::Handle<v8::ObjectTemplate>(),
                            shadow_attrs,
                            sizeof(shadow_attrs)/sizeof(*shadow_attrs));
   return templ;
 }
 END
     }
 
     # Generate the template configuration method
     push(@implContent,  <<END);
 static v8::Persistent<v8::FunctionTemplate> Configure${className}Template(v8::Persistent<v8::FunctionTemplate> desc) {
   v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
   instance->SetInternalFieldCount(2);
   v8::Local<v8::Signature> default_signature = v8::Signature::New(desc);
   v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
   $access_check
 END
 
 
     # Set up our attributes if we have them
     if ($has_attributes) {
       push(@implContent, <<END);
-  BatchConfigureAttributes(instance, proto, attrs, sizeof(attrs)/sizeof(*attrs));
+  batchConfigureAttributes(instance, proto, attrs, sizeof(attrs)/sizeof(*attrs));
 END
     }
 
     # Define our functions with Set() or SetAccessor()
     foreach my $function (@{$dataNode->functions}) {
       my $attrExt = $function->signature->extendedAttributes;
       my $name = $function->signature->name;
 
       my $property_attributes = "v8::DontDelete";
       if ($attrExt->{"DontEnum"}) {
@@ skipping 64 matching lines @@
       static_cast<v8::PropertyAttribute>($property_attributes));
 END
     }
 
     # set the super descriptor
     foreach (@{$dataNode->parents}) {
       my $parent = $codeGenerator->StripModule($_);
       if ($parent eq "EventTarget") { next; }
       $implIncludes{"V8${parent}.h"} = 1;
       my $parentClassIndex = uc($codeGenerator->StripModule($parent));
-      push(@implContent, "  desc->Inherit(V8Proxy::GetTemplate(V8ClassIndex::${parentClassIndex}));\n");
+      push(@implContent, "  desc->Inherit(V8Proxy::getTemplate(V8ClassIndex::${parentClassIndex}));\n");
       last;
     }
 
     # Set the class name.  This is used when printing objects.
     push(@implContent, "  desc->SetClassName(v8::String::New(\"" . GetClassName(${interfaceName}) . "\"));\n");
 
     if ($has_constants) {
       push(@implContent, <<END);
-  BatchConfigureConstants(desc, proto, consts, sizeof(consts)/sizeof(*consts));
+  batchConfigureConstants(desc, proto, consts, sizeof(consts)/sizeof(*consts));
 END
     }
 
     push(@implContent, <<END);
   return desc;
 }
 
 v8::Persistent<v8::FunctionTemplate> ${className}::GetRawTemplate() {
   static v8::Persistent<v8::FunctionTemplate> ${className}_raw_cache_;
   if (${className}_raw_cache_.IsEmpty()) {
     v8::HandleScope scope;
-    v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(V8Proxy::CheckNewLegal);
+    v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(V8Proxy::checkNewLegal);
     ${className}_raw_cache_ = v8::Persistent<v8::FunctionTemplate>::New(result);
   }
   return ${className}_raw_cache_;
 }
 
 v8::Persistent<v8::FunctionTemplate> ${className}::GetTemplate() {
   static v8::Persistent<v8::FunctionTemplate> ${className}_cache_;
   if (${className}_cache_.IsEmpty())
     ${className}_cache_ = Configure${className}Template(GetRawTemplate());
   return ${className}_cache_;
@@ skipping 122 matching lines @@
 
   if ($nodeToReturn) {
     # Special case for insertBefore, replaceChild, removeChild and
     # appendChild functions from Node.
     $result .= $indent . "bool success = $functionString;\n";
     if (@{$function->raisesExceptions}) {
       $result .= GenerateSetDOMException($indent);
     }
     $result .= $indent . "if (success)\n";
     $result .= $indent . "    " . 
-      "return V8Proxy::NodeToV8Object($nodeToReturn);\n";
+      "return V8Proxy::convertNodeToV8Object($nodeToReturn);\n";
     $result .= $indent . "return v8::Null();\n";
     return $result;
   } elsif ($returnType eq "void") {
     $result .= $indent . "$functionString;\n";
   } elsif ($copyFirst) {
     $result .= 
       $indent . GetNativeType($returnType, 0) . " result = *imp;\n" .
       $indent . "$functionString;\n";
   } elsif ($returnsListItemPodType) {
     $result .= $indent . "RefPtr<SVGPODListItem<$nativeReturnType> > result = $functionString;\n";
@@ skipping 44 matching lines @@
     if (!$generatedSVGContextRetrieval) {
       $result .= GenerateSVGContextRetrieval($implClassName, $indent);
       $generatedSVGContextRetrieval = 1;
     }
     
     $result .= $indent . "imp_wrapper->commitChange(imp_instance, context);\n";
   }
   
   if ($returnsPodType) {
     my $classIndex = uc($returnType);
-    $result .= $indent . "return V8Proxy::ToV8Object(V8ClassIndex::$classIndex, wrapper);\n";
+    $result .= $indent . "return V8Proxy::convertToV8Object(V8ClassIndex::$classIndex, wrapper);\n";
   } else {
     $result .= $indent . "return " . NativeToJSValue($function->signature, $return) . ";\n"; 
   }
 
   return $result;
 }
 
 
 # Get the class name used for printing javascript DOM-object wrappers.
 sub GetClassName
@@ skipping 243 matching lines @@
     return "static_cast<SVGPaint::SVGPaintType>($value->ToInt32()->Int32Value())" if $type eq "SVGPaintType";
 
     return "ToWebCoreString($value)" if $type eq "AtomicString" or $type eq "DOMUserData";
     if ($type eq "DOMString") {
         return "valueToStringWithNullCheck($value)" if $signature->extendedAttributes->{"ConvertNullToNullString"};
         return "valueToStringWithNullOrUndefinedCheck($value)" if $signature->extendedAttributes->{"ConvertUndefinedOrNullToNullString"};
         return "ToWebCoreString($value)";
     }
 
     if ($type eq "NodeFilter") {
-        return "V8Proxy::ToNativeNodeFilter($value)";
+        return "V8Proxy::wrapNativeNodeFilter($value)";
     }
 
     if ($type eq "SVGRect") {
         $implIncludes{"FloatRect.h"} = 1;
     }
 
     if ($type eq "SVGPoint") {
         $implIncludes{"FloatPoint.h"} = 1;
     }
 
     # Default, assume autogenerated type conversion routines
-    $implIncludes{"v8_proxy.h"} = 1;
+    $implIncludes{"V8Proxy.h"} = 1;
     if ($type eq "EventTarget") {
       $implIncludes{"V8Node.h"} = 1;
 
       # EventTarget is not in DOM hierarchy, but all Nodes are EventTarget.
-      return "V8Node::HasInstance($value) ? V8Proxy::DOMWrapperToNode<Node>($value) : 0";
+      return "V8Node::HasInstance($value) ? V8Proxy::convertDOMWrapperToNode<Node>($value) : 0";
     }
 
     AddIncludesForType($type);
     # $implIncludes{"$type.h"} = 1 unless AvoidInclusionOfType($type);
 
     if (IsDOMNodeType($type)) {
       $implIncludes{"V8${type}.h"} = 1;
       
       # Perform type checks on the parameter, if it is expected Node type,
       # return NULL.
-      return "V8${type}::HasInstance($value) ? V8Proxy::DOMWrapperToNode<${type}>($value) : 0";
+      return "V8${type}::HasInstance($value) ? V8Proxy::convertDOMWrapperToNode<${type}>($value) : 0";
 
     } else {
       # TODO: Temporary to avoid Window name conflict.
       my $classIndex = uc($type);
       my $implClassName = ${type};
 
       $implIncludes{"V8$type.h"} = 1;
       
       if ($codeGenerator->IsPodType($type)) {
         my $nativeType = GetNativeType($type);
         $implIncludes{"V8SVGPODTypeWrapper.h"} = 1;
 
         return "V8SVGPODTypeUtil::ToSVGPODType<${nativeType}>(V8ClassIndex::${classIndex}, $value${maybeOkParam})"
       }
       
       $implIncludes{"V8${type}.h"} = 1;
 
       # Perform type checks on the parameter, if it is expected Node type,
       # return NULL.
-      return "V8${type}::HasInstance($value) ? V8Proxy::ToNativeObject<${implClassName}>(V8ClassIndex::${classIndex}, $value) : 0";
+      return "V8${type}::HasInstance($value) ? V8Proxy::convertToNativeObject<${implClassName}>(V8ClassIndex::${classIndex}, $value) : 0";
     }
 }
 
 
 sub GetV8HeaderName
 {
     my $type = shift;
     return "V8" . GetImplementationFileName($type);
 }
 
@@ skipping 133 matching lines @@
         return "v8String($value)";
     }
 
     # V8 specific.
     my $implClassName = $type;
     AddIncludesForType($type);
     # $implIncludes{GetImplementationFileName($type)} = 1 unless AvoidInclusionOfType($type);
 
     # special case for non-DOM node interfaces
     if (IsDOMNodeType($type)) {
-      return "V8Proxy::NodeToV8Object($value)";
+      return "V8Proxy::convertNodeToV8Object($value)";
     }
 
     if ($type eq "EventTarget" or $type eq "SVGElementInstance") {
-      return "V8Proxy::EventTargetToV8Object($value)";
+      return "V8Proxy::convertEventTargetToV8Object($value)";
     }
 
     if ($type eq "Event") {
-      return "V8Proxy::EventToV8Object($value)";
+      return "V8Proxy::convertEventToV8Object($value)";
     }
 
     if ($type eq "EventListener") {
-      return "V8Proxy::EventListenerToV8Object($value)";
+      return "V8Proxy::convertEventListenerToV8Object($value)";
     }
 
     if ($type eq "RGBColor") {
-      return "V8Proxy::ToV8Object(V8ClassIndex::RGBCOLOR, new RGBColor($value))";
+      return "V8Proxy::convertToV8Object(V8ClassIndex::RGBCOLOR, new RGBColor($value))";
     }
     
     if ($type eq "WorkerContext" or $type eq "WorkerLocation" or $type eq "WorkerNavigator") {
       $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
       my $classIndex = uc($type);
 
       return "WorkerContextExecutionProxy::ToV8Object(V8ClassIndex::$classIndex, $value)";
     }
 
     else {
       $implIncludes{"wtf/RefCounted.h"} = 1;
       $implIncludes{"wtf/RefPtr.h"} = 1;
       my $classIndex = uc($type);
       
       if ($codeGenerator->IsPodType($type)) {
         $value = GenerateSVGStaticPodTypeWrapper($type, $value);
       }
 
-      return "V8Proxy::ToV8Object(V8ClassIndex::$classIndex, $value)";
+      return "V8Proxy::convertToV8Object(V8ClassIndex::$classIndex, $value)";
     }
 }
 
 sub GenerateSVGStaticPodTypeWrapper {
   my $type = shift;
   my $value = shift;
   
   $implIncludes{"V8$type.h"}=1;
   $implIncludes{"V8SVGPODTypeWrapper.h"} = 1;
 
@@ skipping 51 matching lines @@
     return 0;
 }
 
 sub GenerateSVGContextAssignment
 {
     my $srcType = shift;
     my $value = shift;
     my $indent = shift;
     
     $result = GenerateSVGContextRetrieval($srcType, $indent);
-    $result .=   $indent . "V8Proxy::SetSVGContext($value, context);\n";
+    $result .=   $indent . "V8Proxy::setSVGContext($value, context);\n";
     
     return $result;
 }
 
 sub GenerateSVGContextRetrieval
 {
   my $srcType = shift;
   my $indent = shift;
 
   my $srcIsPodType = $codeGenerator->IsPodType($srcType);
   
   my $srcObject = "imp";
   if ($srcIsPodType) {
     $srcObject = "imp_wrapper";
   }
 
   my $contextDecl;
   
   if (IsSVGTypeNeedingContextParameter($srcType)) {
-    $contextDecl = "V8Proxy::GetSVGContext($srcObject)";
+    $contextDecl = "V8Proxy::svgContext($srcObject)";
   } else {
     $contextDecl = $srcObject;
   }
 
   return $indent . "SVGElement* context = $contextDecl;\n";
 }
 
 sub IsSVGListMutator
 {
   my $functionName = shift;
@@ skipping 29 matching lines @@
   return 0;
 }
   
 sub DebugPrint
 {
   my $output = shift;
   
   print $output;
   print "\n";
 }