JSRPC: Support "serializing" functions by turning them into stubs #1756

The default behavior of V8 serialization (and structured clone, I guess) is to serialize a class instance as if it were a plain object, completely ignoring the prototype. This is probably not useful in real use cases since it is lossy. So, we'd prefer that this just fails, both because it's not useful and because we might want to introduce better behavior in the future.

V8's default implementation of `WriteHostObject()` is pretty bad. It does NOT call `ThrowDataCloneError()`; instead it throws a regular old `Error`. The error message is also very weird, it puts the characters `#<>` around the type name. This commit changes to throwing a DataCloneError with a nicer error message.

This required a V8 patch to allow functions to be treated as host objects. This commit constructs the RpcStubs but they are not actually callable yet -- there is more work to be done in subsequent commits.

We need to make RpcStub itself callable, so having this as a private method of JsRpcProperty no longer works.

We can just use an old fashion if statement here.

…ables. We're about to make JsRpcPromise be callable, which makes it a function. But `isValidThenable()` in `internal_asserts.ts` thinks that thenables cannot be callable, which means `assert.rejects` doesn't our promises. This commit monkey-patches it to solve the problem, but maybe `isValidThenable()` itself should change...

…le thenables. This lets us get rid of the monkey-patch in js-rpc-test.js, but I'm not completely sure if it's correct. It does seem that V8 itself accepts callable thenables, but the check here looks very explicit so I'm not sure if it has a reason. `isValidThenable()` was also requiring the presence of a `catch` method, but this is not actually a requirement of thenables, so I removed that check as well.

This allows a stub to point to a bare function, and allows an RPC to directly return a bare function.

Sometimes people make a "callable object" by creating a function and then giving it properties. We should support this. I had originally wanted to disallow this if the function's prototype had been tampered with, like: ``` let func = () => {}; func.__proto__ = SomeClass.prototype; ``` This technique allows you to create a "callable class instance". In theory we ought to treat it like a user-defined class, i.e., don't support it, unless it extends JsRpcTarget. Unfortunately, it's sort of hard to distinguish "plain functions". There are multiple prototypes to check for: Function, AsyncFunction, and maybe others. I decided to give up and say that we treat all callable objects as functions.

…ctions. Since these types are callable, `IsFunction()` returns true, but if we want to actually handle "serializing" these, we need it to work very differently. So, make sure we don't count them, and add some tests. In the future we might decide to actually support these.

This should be the same as a class instance of application-defined type.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

JSRPC: Support "serializing" functions by turning them into stubs #1756

JSRPC: Support "serializing" functions by turning them into stubs #1756

Commits on Mar 5, 2024