/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef js_CallNonGenericMethod_h #define js_CallNonGenericMethod_h #include "jstypes.h" #include "js/CallArgs.h" namespace JS { // Returns true if |v| is considered an acceptable this-value. typedef bool (*IsAcceptableThis)(HandleValue v); // Implements the guts of a method; guaranteed to be provided an acceptable // this-value, as determined by a corresponding IsAcceptableThis method. typedef bool (*NativeImpl)(JSContext* cx, const CallArgs& args); namespace detail { // DON'T CALL THIS DIRECTLY. It's for use only by CallNonGenericMethod! extern JS_PUBLIC_API(bool) CallMethodIfWrapped(JSContext* cx, IsAcceptableThis test, NativeImpl impl, const CallArgs& args); } // namespace detail // Methods usually act upon |this| objects only from a single global object and // compartment. Sometimes, however, a method must act upon |this| values from // multiple global objects or compartments. In such cases the |this| value a // method might see will be wrapped, such that various access to the object -- // to its class, its private data, its reserved slots, and so on -- will not // work properly without entering that object's compartment. This method // implements a solution to this problem. // // To implement a method that accepts |this| values from multiple compartments, // define two functions. The first function matches the IsAcceptableThis type // and indicates whether the provided value is an acceptable |this| for the // method; it must be a pure function only of its argument. // // static const JSClass AnswerClass = { ... }; // // static bool // IsAnswerObject(const Value& v) // { // if (!v.isObject()) // return false; // return JS_GetClass(&v.toObject()) == &AnswerClass; // } // // The second function implements the NativeImpl signature and defines the // behavior of the method when it is provided an acceptable |this| value. // Aside from some typing niceties -- see the CallArgs interface for details -- // its interface is the same as that of JSNative. // // static bool // answer_getAnswer_impl(JSContext* cx, JS::CallArgs args) // { // args.rval().setInt32(42); // return true; // } // // The implementation function is guaranteed to be called *only* with a |this| // value which is considered acceptable. // // Now to implement the actual method, write a JSNative that calls the method // declared below, passing the appropriate template and runtime arguments. // // static bool // answer_getAnswer(JSContext* cx, unsigned argc, JS::Value* vp) // { // JS::CallArgs args = JS::CallArgsFromVp(argc, vp); // return JS::CallNonGenericMethod<IsAnswerObject, answer_getAnswer_impl>(cx, args); // } // // Note that, because they are used as template arguments, the predicate // and implementation functions must have external linkage. (This is // unfortunate, but GCC wasn't inlining things as one would hope when we // passed them as function arguments.) // // JS::CallNonGenericMethod will test whether |args.thisv()| is acceptable. If // it is, it will call the provided implementation function, which will return // a value and indicate success. If it is not, it will attempt to unwrap // |this| and call the implementation function on the unwrapped |this|. If // that succeeds, all well and good. If it doesn't succeed, a TypeError will // be thrown. // // Note: JS::CallNonGenericMethod will only work correctly if it's called in // tail position in a JSNative. Do not call it from any other place. // template<IsAcceptableThis Test, NativeImpl Impl> MOZ_ALWAYS_INLINE bool CallNonGenericMethod(JSContext* cx, const CallArgs& args) { HandleValue thisv = args.thisv(); if (Test(thisv)) return Impl(cx, args); return detail::CallMethodIfWrapped(cx, Test, Impl, args); } MOZ_ALWAYS_INLINE bool CallNonGenericMethod(JSContext* cx, IsAcceptableThis Test, NativeImpl Impl, const CallArgs& args) { HandleValue thisv = args.thisv(); if (Test(thisv)) return Impl(cx, args); return detail::CallMethodIfWrapped(cx, Test, Impl, args); } } // namespace JS #endif /* js_CallNonGenericMethod_h */