Simplify invokeCallback() and support void return values for IDL callbacks

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 4846 matching lines @@
     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 PassOwnPtr<${v8ClassName}> create(v8::Handle<v8::Object> callback, ExecutionContext* context)
+    static PassOwnPtr<${v8ClassName}> create(v8::Handle<v8::Function> callback, ExecutionContext* context)
     {
         ASSERT(context);
         return adoptPtr(new ${v8ClassName}(callback, context));
     }
 
     virtual ~${v8ClassName}();
 
 END
 
     # Functions
@@ skipping 10 matching lines @@
             foreach my $param (@params) {
                 push(@args, GetNativeTypeForCallbacks($param->type) . " " . $param->name);
             }
             $code .= join(", ", @args);
             $code .= ");\n";
             $header{classPublic}->add($code);
         }
     }
 
     $header{classPrivate}->add(<<END);
-    ${v8ClassName}(v8::Handle<v8::Object>, ExecutionContext*);
+    ${v8ClassName}(v8::Handle<v8::Function>, ExecutionContext*);
 
-    ScopedPersistent<v8::Object> m_callback;
+    ScopedPersistent<v8::Function> m_callback;
     RefPtr<DOMWrapperWorld> m_world;
 END
 }
 
 sub GenerateCallbackImplementation
 {
     my $object = shift;
     my $interface = shift;
     my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("core/dom/ExecutionContext.h");
     AddToImplIncludes("bindings/v8/V8Binding.h");
     AddToImplIncludes("bindings/v8/V8Callback.h");
     AddToImplIncludes("wtf/Assertions.h");
 
     $implementation{nameSpaceWebCore}->add(<<END);
-${v8ClassName}::${v8ClassName}(v8::Handle<v8::Object> callback, ExecutionContext* context)
+${v8ClassName}::${v8ClassName}(v8::Handle<v8::Function> callback, ExecutionContext* context)
     : ActiveDOMCallback(context)
     , m_callback(toIsolate(context), callback)
     , m_world(DOMWrapperWorld::current())
 {
 }
 
 END
 
     $implementation{nameSpaceWebCore}->add(<<END);
 ${v8ClassName}::~${v8ClassName}()
 {
 }
 
 END
 
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         foreach my $function (@{$interface->functions}) {
             my $code = "";
             my @params = @{$function->parameters};
             next if $function->extendedAttributes->{"Custom"};
 
             AddIncludesForType($function->type);
-            die "We don't yet support callbacks that return non-boolean values.\n" if $function->type ne "boolean";
+            die "We only support callbacks that return boolean or void values.\n" unless ($function->type eq "boolean" || $function->type eq "void");
+            my $defaultReturn = $function->type eq "boolean" ? " true" : "";
             $code .= GetNativeTypeForCallbacks($function->type) . " ${v8ClassName}::" . $function->name . "(";
             my $callWithThisValue = ExtendedAttributeContains($function->extendedAttributes->{"CallWith"}, "ThisValue");
 
             my @args = ();
             if ($callWithThisValue) {
                 push(@args, GetNativeTypeForCallbacks("any") . " thisValue");
             }
             foreach my $param (@params) {
                 my $paramName = $param->name;
                 my $type = $param->type;
                 my $arrayOrSequenceType = GetArrayOrSequenceType($type);
 
                 if ($arrayOrSequenceType) {
                     if (IsRefPtrType($arrayOrSequenceType)) {
                         AddIncludesForType($arrayOrSequenceType);
                      }
                 } else {
                     AddIncludesForType($type);
                 }
 
                 push(@args, GetNativeTypeForCallbacks($type) . " " . $paramName);
             }
             $code .= join(", ", @args);
 
             $code .= ")\n";
             $code .= "{\n";
             $code .= "    if (!canInvokeCallback())\n";
-            $code .= "        return true;\n\n";
+            $code .= "        return${defaultReturn};\n\n";
             $code .= "    v8::Isolate* isolate = v8::Isolate::GetCurrent();\n";
             $code .= "    v8::HandleScope handleScope(isolate);\n\n";
             $code .= "    v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());\n";
             $code .= "    if (v8Context.IsEmpty())\n";
-            $code .= "        return true;\n\n";
+            $code .= "        return${defaultReturn};\n\n";
             $code .= "    v8::Context::Scope scope(v8Context);\n";
 
             my $thisObjectHandle = "";
             if ($callWithThisValue) {
                 $code .= "    v8::Handle<v8::Value> thisHandle = thisValue.v8Value();\n";
                 $code .= "    if (thisHandle.IsEmpty()) {\n";
                 $code .= "        if (!isScriptControllerTerminating())\n";
                 $code .= "            CRASH();\n";
-                $code .= "        return true;\n";
+                $code .= "        return${defaultReturn};\n";
                 $code .= "    }\n";
                 $code .= "    ASSERT(thisHandle->IsObject());\n";
                 $thisObjectHandle = "v8::Handle<v8::Object>::Cast(thisHandle), ";
             }
             @args = ();
             foreach my $param (@params) {
                 my $paramName = $param->name;
                 $code .= NativeToJSValue($param->type, $param->extendedAttributes, $paramName, "    ", "v8::Handle<v8::Value> ${paramName}Handle =", "isolate", "") . "\n";
                 $code .= "    if (${paramName}Handle.IsEmpty()) {\n";
                 $code .= "        if (!isScriptControllerTerminating())\n";
                 $code .= "            CRASH();\n";
-                $code .= "        return true;\n";
+                $code .= "        return${defaultReturn};\n";
                 $code .= "    }\n";
                 push(@args, "${paramName}Handle");
             }
 
             if (scalar(@args) > 0) {
                 $code .= "    v8::Handle<v8::Value> argv[] = { ";
                 $code .= join(", ", @args);
                 $code .= " };\n\n";
             } else {
                 $code .= "    v8::Handle<v8::Value> *argv = 0;\n\n";
             }
-            $code .= "    bool callbackReturnValue = false;\n";
-            $code .= "    return !invokeCallback(m_callback.newLocal(isolate), ${thisObjectHandle}" . scalar(@args) . ", argv, callbackReturnValue, executionContext(), isolate);\n";
+            $code .= "    ";
+            if ($function->type eq "boolean") {
+                $code .= "return ";
+            }
+            $code .= "invokeCallback(m_callback.newLocal(isolate), ${thisObjectHandle}" . scalar(@args) . ", argv, executionContext(), isolate);\n";
             $code .= "}\n\n";
             $implementation{nameSpaceWebCore}->add($code);
         }
     }
 }
 
 sub GenerateSpecialWrap
 {
     my $interface = shift;
     my $v8ClassName = shift;
@@ skipping 384 matching lines @@
 
     # Default, assume native type is a pointer with same type name as idl type
     return "${type}*";
 }
 
 sub GetNativeTypeForCallbacks
 {
     my $type = shift;
     return "const String&" if $type eq "DOMString";
     return "PassRefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
+    return "void" if $type eq "void";
 
     # Callbacks use raw pointers, so pass isParameter = 1
     my $nativeType = GetNativeType($type, {}, "parameter");
     return "const $nativeType&" if $nativeType =~ /^Vector/;
     return $nativeType;
 }
 
 sub JSValueToNativeStatement
 {
     my $type = shift;
@@ skipping 954 matching lines @@
 
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "ToV8");
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "Wrap");
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;