Simplify Custom Element constructors to be functions, not wrappers

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 170 matching lines @@
                       "Uint8ClampedArray" => ["unsigned char", "v8::kExternalPixelArray"],
                       "Uint16Array" => ["unsigned short", "v8::kExternalUnsignedShortArray"],
                       "Uint32Array" => ["unsigned int", "v8::kExternalUnsignedIntArray"],
                       "Int8Array" => ["signed char", "v8::kExternalByteArray"],
                       "Int16Array" => ["short", "v8::kExternalShortArray"],
                       "Int32Array" => ["int", "v8::kExternalIntArray"],
                       "Float32Array" => ["float", "v8::kExternalFloatArray"],
                       "Float64Array" => ["double", "v8::kExternalDoubleArray"],
                      );
 
+my %callbackFunctionTypeHash = ();
+
 my %enumTypeHash = ();
 
 my %svgAnimatedTypeHash = ("SVGAnimatedAngle" => 1, "SVGAnimatedBoolean" => 1,
                            "SVGAnimatedEnumeration" => 1, "SVGAnimatedInteger" => 1,
                            "SVGAnimatedLength" => 1, "SVGAnimatedLengthList" => 1,
                            "SVGAnimatedNumber" => 1, "SVGAnimatedNumberList" => 1,
                            "SVGAnimatedPreserveAspectRatio" => 1,
                            "SVGAnimatedRect" => 1, "SVGAnimatedString" => 1,
                            "SVGAnimatedTransformList" => 1);
 
@@ skipping 117 matching lines @@
     }
 
     die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 sub GenerateInterface
 {
     my $object = shift;
     my $interface = shift;
 
+    %callbackFunctionTypeHash = map { $_->name => $_ } @{$idlDocument->callbackFunctions};
     %enumTypeHash = map { $_->name => $_->values } @{$idlDocument->enumerations};
     my $v8ClassName = GetV8ClassName($interface);
     my $defineName = $v8ClassName . "_h";
     my $internalNamespace = GetImplName($interface) . "V8Internal";
 
     my $conditionalString = GenerateConditionalString($interface);
     my $conditionalIf = "";
     my $conditionalEndif = "";
     if ($conditionalString) {
         $conditionalIf = "#if ${conditionalString}";
@@ skipping 70 matching lines @@
         $headerIncludes{$include} = 1;
     }
 }
 
 sub SkipIncludeHeader
 {
     my $type = shift;
 
     return 1 if IsPrimitiveType($type);
     return 1 if IsEnumType($type);
+    return 1 if IsCallbackFunctionType($type);
     return 1 if $type eq "DOMString";
 
     # Special case: SVGPoint.h / SVGNumber.h do not exist.
     return 1 if $type eq "SVGPoint" or $type eq "SVGNumber";
     return 0;
 }
 
 sub AddIncludesForType
 {
     my $type = shift;
 
     return if SkipIncludeHeader($type);
 
     # Default includes
     if ($type eq "EventListener") {
         AddToImplIncludes("core/dom/EventListener.h");
     } elsif ($type eq "SerializedScriptValue") {
         AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
-    } elsif ($type eq "any") {
+    } elsif ($type eq "any" || IsCallbackFunctionType($type)) {
         AddToImplIncludes("bindings/v8/ScriptValue.h");
     } else {
         AddToImplIncludes("V8${type}.h");
     }
 
     # Additional includes
     if ($type eq "CSSStyleSheet") {
         AddToImplIncludes("core/css/CSSImportRule.h");
     }
 }
@@ skipping 207 matching lines @@
 public:
     static v8::Handle<v8::FunctionTemplate> GetTemplate(v8::Isolate*, WrapperWorldType);
     static WrapperTypeInfo info;
 };
 END
     }
 
     $header{class}->addHeader("class $v8ClassName {");
     $header{class}->addFooter("};");
 
-    my $fromFunctionOpening = "";
-    my $fromFunctionClosing = "";
-    if ($interface->extendedAttributes->{"WrapAsFunction"}) {

[haraken, 2013/06/10 09:11:03]

Now you can remove [WrapAsFunction] from IDLAttribute.txt as well.

-        $fromFunctionOpening = "V8DOMWrapper::fromFunction(";
-        $fromFunctionClosing = ")";
-    }
-
     $header{classPublic}->add(<<END);
     static bool HasInstance(v8::Handle<v8::Value>, v8::Isolate*, WrapperWorldType);
     static bool HasInstanceInAnyWorld(v8::Handle<v8::Value>, v8::Isolate*);
     static v8::Handle<v8::FunctionTemplate> GetTemplate(v8::Isolate*, WrapperWorldType);
     static ${nativeType}* toNative(v8::Handle<v8::Object> object)
     {
-        return reinterpret_cast<${nativeType}*>(${fromFunctionOpening}object${fromFunctionClosing}->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex));
+        return reinterpret_cast<${nativeType}*>(object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex));
     }
     static void derefObject(void*);
     static WrapperTypeInfo info;
 END
 
     if (NeedsOpaqueRootForGC($interface)) {
         $header{classPublic}->add("    static void* opaqueRootForGC(void*, v8::Isolate*);\n");
     }
 
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
@@ skipping 152 matching lines @@
 
 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 ? "${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"} ? ", \"${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_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == ${v8ClassName}::info.derefObjectFunction);
     }
-    return ${returningCreatedWrapperOpening}$createWrapperCall(impl, creationContext, isolate)${returningCreatedWrapperClosing};
+    return $createWrapperCall(impl, creationContext, isolate);
 }
 END
         }
 
         $header{nameSpaceWebCore}->add(<<END);
 
 inline v8::Handle<v8::Value> toV8(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (UNLIKELY(!impl))
         return v8NullWithCheck(isolate);
     v8::Handle<v8::Value> wrapper = DOMDataStore::getWrapper(impl, isolate);
     if (!wrapper.IsEmpty())
-        return $returningWrapper;
+        return wrapper;
     return wrap(impl, creationContext, isolate);
 }
 
 inline v8::Handle<v8::Value> toV8ForMainWorld(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(worldType(isolate) == MainWorld);
     if (UNLIKELY(!impl))
         return v8NullWithCheck(isolate);
     v8::Handle<v8::Value> wrapper = DOMDataStore::getWrapperForMainWorld(impl);
     if (!wrapper.IsEmpty())
-        return $returningWrapper;
+        return wrapper;
     return wrap(impl, creationContext, isolate);
 }
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8Fast(${nativeType}* impl, const HolderContainer& container, Wrappable* wrappable)
 {
     if (UNLIKELY(!impl))
         return v8Null(container.GetIsolate());
     v8::Handle<v8::Object> wrapper = DOMDataStore::getWrapperFast(impl, container, wrappable);
     if (!wrapper.IsEmpty())
-        return $returningWrapper;
+        return wrapper;
     return wrap(impl, container.Holder(), container.GetIsolate());
 }
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8FastForMainWorld(${nativeType}* impl, const HolderContainer& container, Wrappable* wrappable)
 {
     ASSERT(worldType(container.GetIsolate()) == MainWorld);
     if (UNLIKELY(!impl))
         return v8Null(container.GetIsolate());
     v8::Handle<v8::Object> wrapper = DOMDataStore::getWrapperForMainWorld(impl);
     if (!wrapper.IsEmpty())
-        return $returningWrapper;
+        return wrapper;
     return wrap(impl, container.Holder(), container.GetIsolate());
 }
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8FastForMainWorld(PassRefPtr< ${nativeType} > impl, const HolderContainer& container, Wrappable* wrappable)
 {
     return toV8FastForMainWorld(impl.get(), container, wrappable);
 }
 
 END
@@ skipping 3878 matching lines @@
     return "long long" if $type eq "long long";
     return "unsigned long long" if $type eq "unsigned long long";
     return "bool" if $type eq "boolean";
 
     return "V8StringResource" if ($type eq "DOMString" or IsEnumType($type)) and $isParameter;
     return "String" if $type eq "DOMString" or IsEnumType($type);
 
     return "Range::CompareHow" if $type eq "CompareHow";
     return "DOMTimeStamp" if $type eq "DOMTimeStamp";
     return "double" if $type eq "Date";
-    return "ScriptValue" if $type eq "any";
+    return "ScriptValue" if $type eq "any" or IsCallbackFunctionType($type);
     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);
 
@@ skipping 63 matching lines @@
     if ($type eq "SerializedScriptValue") {
         AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         return "SerializedScriptValue::create($value, $getIsolate)";
     }
 
     if ($type eq "Dictionary") {
         AddToImplIncludes("bindings/v8/Dictionary.h");
         return "Dictionary($value, $getIsolate)";
     }
 
-    if ($type eq "any") {
+    if ($type eq "any" || IsCallbackFunctionType($type)) {
         AddToImplIncludes("bindings/v8/ScriptValue.h");
         return "ScriptValue($value)";
     }
 
     if ($type eq "NodeFilter") {
         return "toNodeFilter($value)";
     }
 
     if ($type eq "MediaQueryListListener") {
         AddToImplIncludes("core/css/MediaQueryListListener.h");
@@ skipping 111 matching lines @@
         return 1;
     }
     return 0;
 }
 
 sub IsWrapperType
 {
     my $type = shift;
     return 0 if GetArrayType($type);
     return 0 if GetSequenceType($type);
+    return 0 if IsCallbackFunctionType($type);
     return 0 if IsEnumType($type);
     return 0 if IsPrimitiveType($type);
     return 0 if $type eq "DOMString";
     return !$nonWrapperTypes{$type};
 }
 
 sub IsCallbackInterface
 {
     my $type = shift;
     return 0 unless IsWrapperType($type);
@@ skipping 405 matching lines @@
 }
 
 sub IsPrimitiveType
 {
     my $type = shift;
 
     return 1 if $primitiveTypeHash{$type};
     return 0;
 }
 
+sub IsCallbackFunctionType
+{
+    my $type = shift;
+
+    return 1 if $callbackFunctionTypeHash{$type};
+    return 0;
+}
+
 sub IsEnumType
 {
     my $type = shift;
 
     return 1 if $enumTypeHash{$type};
     return 0;
 }
 
 sub ValidEnumValues
 {
@@ skipping 22 matching lines @@
 {
     my $type = shift;
     return 1 if $typedArrayHash{$type};
     return 0;
 }
 
 sub IsRefPtrType
 {
     my $type = shift;
 
+    return 0 if $type eq "any";
     return 0 if IsPrimitiveType($type);
     return 0 if GetArrayType($type);
     return 0 if GetSequenceType($type);
     return 0 if $type eq "DOMString";
+    return 0 if IsCallbackFunctionType($type);
     return 0 if IsEnumType($type);
     return 0 if IsUnionType($type);
 
     return 1;
 }
 
 sub GetSVGTypeNeedingTearOff
 {
     my $type = shift;
 
@@ skipping 322 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;