Make IDL Callbacks non-refcounted by default

Source/bindings/scripts/code_generator_v8.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 2535 matching lines @@
             $parameterCheckString .= <<END;
         return;
     }
 END
         }
 
         my $parameterName = $parameter->name;
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         if (IsCallbackInterface($parameter->type)) {
+            my $ptrType = IsLegacyRefCountedCallback($parameter->type) ? "Ref" : "Own";
             my $v8ClassName = "V8" . $parameter->type;
             AddToImplIncludes("$v8ClassName.h");
             if ($parameter->isOptional) {
-                $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
+                $parameterCheckString .= "    ${ptrType}Ptr<" . $parameter->type . "> $parameterName;\n";
                 $parameterCheckString .= "    if (info.Length() > $paramIndex && !info[$paramIndex]->IsNull() && !info[$paramIndex]->IsUndefined()) {\n";
                 $parameterCheckString .= "        if (!info[$paramIndex]->IsFunction()) {\n";
                 $parameterCheckString .= "            throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), info.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
                 $parameterCheckString .= "        }\n";
                 $parameterCheckString .= "        $parameterName = ${v8ClassName}::create(info[$paramIndex], getExecutionContext());\n";
                 $parameterCheckString .= "    }\n";
             } else {
                 $parameterCheckString .= "    if (info.Length() <= $paramIndex || ";
                 if ($parameter->isNullable) {
                     $parameterCheckString .= "!(info[$paramIndex]->IsFunction() || info[$paramIndex]->IsNull())";
                 } else {
                     $parameterCheckString .= "!info[$paramIndex]->IsFunction()";
                 }
                 $parameterCheckString .= ") {\n";
                 $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), info.GetIsolate());\n";
                 $parameterCheckString .= "        return;\n";
                 $parameterCheckString .= "    }\n";
-                $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ";
-                $parameterCheckString .= "info[$paramIndex]->IsNull() ? 0 : " if $parameter->isNullable;
+                $parameterCheckString .= "    ${ptrType}Ptr<" . $parameter->type . "> $parameterName = ";
+                $parameterCheckString .= "info[$paramIndex]->IsNull() ? nullptr : " if $parameter->isNullable;
                 $parameterCheckString .= "${v8ClassName}::create(info[$paramIndex], getExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
                 my $nativeValue = "${parameterName}NativeValue";
                 my $idlType = $parameter->type;
                 $parameterCheckString .= "    $nativeType $parameterName = 0;\n";
                 $parameterCheckString .= "    V8TRYCATCH_VOID(double, $nativeValue, info[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$idlType>($nativeValue);\n";
         } elsif ($parameter->type eq "SerializedScriptValue") {
@@ skipping 2181 matching lines @@
 }
 
 sub GenerateCallbackHeader
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
+    my $refCounted = IsLegacyRefCountedCallback($interfaceName);
+    my $ptrType = $refCounted ? "Ref" : "Own";
+    my $adoptType = $refCounted ? "Ref" : "Ptr";
 
     my @includes = ();
     push(@includes, "bindings/v8/ActiveDOMCallback.h");
     push(@includes, "bindings/v8/DOMWrapperWorld.h");
     push(@includes, "bindings/v8/ScopedPersistent.h");
     push(@includes, HeaderFilesForInterface($interfaceName, $implClassName));
     for my $include (sort @includes) {
         $header{includes}->add("#include \"$include\"\n");
     }
     $header{nameSpaceWebCore}->addHeader("\nclass ExecutionContext;\n");
     $header{class}->addHeader("class $v8ClassName : public $implClassName, public ActiveDOMCallback {");
     $header{class}->addFooter("};\n");
 
     $header{classPublic}->add(<<END);
-    static PassRefPtr<${v8ClassName}> create(v8::Handle<v8::Value> jsValue, ExecutionContext* context)
+    static Pass${ptrType}Ptr<${v8ClassName}> create(v8::Handle<v8::Value> jsValue, ExecutionContext* context)
     {
         ASSERT(jsValue->IsObject());
         ASSERT(context);
-        return adoptRef(new ${v8ClassName}(v8::Handle<v8::Object>::Cast(jsValue), context));
+        return adopt${adoptType}(new ${v8ClassName}(v8::Handle<v8::Object>::Cast(jsValue), context));
     }
 
     virtual ~${v8ClassName}();
 
 END
 
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         foreach my $function (@{$interface->functions}) {
@@ skipping 1535 matching lines @@
     my $interface = shift;
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"CustomWrap"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
+sub IsLegacyRefCountedCallback

[abarth-chromium, 2013/11/26 21:50:16]

Should this be an IDL attribute instead of hard-coded in the code generator?

[adamk, 2013/11/26 21:54:28]

That would require having the attributes of an interface available whenever that
interface appears in a method signature. I don't believe we currently have that
capability (correct me if I'm wrong).

[haraken, 2013/11/27 00:37:11]

Yeah.

Shall we add a FIXME that IsLegacyRefCountedCallback should be removed?

+{
+    my $name = shift;
+    # WebSQL
+    return 1 if $name eq "DatabaseCallback";
+    return 1 if $name eq "SQLTransactionCallback";
+    return 1 if $name eq "SQLTransactionErrorCallback";
+    return 1 if $name eq "SQLTransactionSyncCallback";
+    return 1 if $name eq "SQLStatementCallback";
+    return 1 if $name eq "SQLStatementErrorCallback";
+    # Filesystem
+    return 1 if $name eq "EntryCallback";
+    return 1 if $name eq "EntriesCallback";
+    return 1 if $name eq "ErrorCallback";
+    return 1 if $name eq "FileCallback";
+    return 1 if $name eq "FileSystemCallback";
+    return 1 if $name eq "FileWriterCallback";
+    return 1 if $name eq "MetadataCallback";
+    # requestAnimationFrame
+    return 1 if $name eq "RequestAnimationFrameCallback";
+    # Used everywhere
+    return 1 if $name eq "VoidCallback";
+    return 0;
+}
+
 1;