Changeset 157234 in webkit for trunk/Source/JavaScriptCore/API/APICallbackFunction.h

Timestamp:

Oct 10, 2013, 11:20:13 AM (12 years ago)

Author:

[email protected]

Message:

Objective-C API: blocks aren't callable via 'new'
​https://bugs.webkit.org/show_bug.cgi?id=122561

Reviewed by Oliver Hunt.

Currently the only way for clients to vend new native objects to JavaScript code
is via factory methods in the form of exported class methods or blocks. Blocks can
be called like normal functions from JavaScript code, but they cannot be invoked
with 'new'. This would give a simple way for clients to expose constructor-like
behavior to their JavaScript code.

This patch adds the ability for blocks to be invoked as if they were a constructor.
Blocks invoked as constructors are required to return an object. If the block doesn't
return an object then an error is thrown. The 'this' object is not provided to the
block and must be created within the block itself.

This patch also unifies the native 'construct' callback used in both the C and Obj-C
APIs under the APICallbackFunction struct, similar to how we unified the 'call' callback
between ObjCCallbackFunction and JSCallbackFunction before.

This patch also adds tests to make sure that different blocks generate objects that
correctly behave when queried with instanceof. It also makes sure that the correct
JS exception is thrown when a block fails to return an object.

• API/APICallbackFunction.h:

(JSC::APICallbackFunction::call):
(JSC::APICallbackFunction::construct):

• API/JSCallbackConstructor.cpp:

(JSC::JSCallbackConstructor::getConstructData):

• API/JSCallbackConstructor.h:

(JSC::JSCallbackConstructor::constructCallback):

• API/JSCallbackFunction.h:

(JSC::JSCallbackFunction::functionCallback):

• API/ObjCCallbackFunction.h:

(JSC::ObjCCallbackFunction::functionCallback):
(JSC::ObjCCallbackFunction::constructCallback):

• API/ObjCCallbackFunction.mm:

(JSC::objCCallbackFunctionCallAsConstructor):
(JSC::ObjCCallbackFunction::ObjCCallbackFunction):
(JSC::ObjCCallbackFunction::create):
(JSC::ObjCCallbackFunction::getConstructData):

• API/tests/testapi.mm:

File:

• trunk/Source/JavaScriptCore/API/APICallbackFunction.h (modified) (4 diffs)

trunk/Source/JavaScriptCore/API/APICallbackFunction.h

@@ -30 +30 @@
 #include "APIShims.h"
 #include "Error.h"
+#include "JSCallbackConstructor.h"
 #include <wtf/Vector.h>
 
@@ -37 +38 @@
 
 template <typename T> static EncodedJSValue JSC_HOST_CALL call(ExecState*);
+template <typename T> static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
 
 };
@@ -57 +59 @@
     {
         APICallbackShim callbackShim(exec);
-        result = jsCast<T*>(toJS(functionRef))->m_callback(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
+        result = jsCast<T*>(toJS(functionRef))->functionCallback()(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
     }
     if (exception)
@@ -68 +70 @@
     return JSValue::encode(toJS(exec, result));
 }
+
+template <typename T>
+EncodedJSValue JSC_HOST_CALL APICallbackFunction::construct(ExecState* exec)
+{
+    JSObject* constructor = exec->callee();
+    JSContextRef ctx = toRef(exec);
+    JSObjectRef constructorRef = toRef(constructor);
+
+    JSObjectCallAsConstructorCallback callback = jsCast<T*>(constructor)->constructCallback();
+    if (callback) {
+        size_t argumentCount = exec->argumentCount();
+        Vector<JSValueRef, 16> arguments;
+        arguments.reserveInitialCapacity(argumentCount);
+        for (size_t i = 0; i < argumentCount; ++i)
+            arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
+
+        JSValueRef exception = 0;
+        JSObjectRef result;
+        {
+            APICallbackShim callbackShim(exec);
+            result = callback(ctx, constructorRef, argumentCount, arguments.data(), &exception);
+        }
+        if (exception) {
+            exec->vm().throwException(exec, toJS(exec, exception));
+            return JSValue::encode(toJS(exec, exception));
+        }
+        // result must be a valid JSValue.
+        if (!result)
+            return throwVMTypeError(exec);
+        return JSValue::encode(toJS(result));
+    }
+    
+    return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(constructor)->classRef(), 0)));
+}
+
 } // namespace JSC