| /* |
| * Copyright 2016 Google Inc. All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // This file has been auto-generated by bindings/code_generator_cobalt.py. DO NOT MODIFY! |
| // Auto-generated from template: bindings/mozjs/templates/interface.cc.template |
| |
| // clang-format off |
| |
| #include "MozjsOperationsTestInterface.h" |
| |
| #include "base/debug/trace_event.h" |
| #include "cobalt/base/polymorphic_downcast.h" |
| #include "cobalt/script/global_environment.h" |
| #include "cobalt/script/opaque_handle.h" |
| #include "cobalt/script/script_object.h" |
| #include "MozjsArbitraryInterface.h" |
| #include "cobalt/bindings/testing/arbitrary_interface.h" |
| |
| #include "base/lazy_instance.h" |
| #include "cobalt/script/mozjs/callback_function_conversion.h" |
| #include "cobalt/script/exception_state.h" |
| #include "cobalt/script/mozjs/conversion_helpers.h" |
| #include "cobalt/script/mozjs/mozjs_exception_state.h" |
| #include "cobalt/script/mozjs/mozjs_callback_function.h" |
| #include "cobalt/script/mozjs/mozjs_global_environment.h" |
| #include "cobalt/script/mozjs/mozjs_object_handle.h" |
| #include "cobalt/script/mozjs/mozjs_property_enumerator.h" |
| #include "cobalt/script/mozjs/mozjs_user_object_holder.h" |
| #include "cobalt/script/mozjs/proxy_handler.h" |
| #include "cobalt/script/mozjs/type_traits.h" |
| #include "cobalt/script/mozjs/wrapper_factory.h" |
| #include "cobalt/script/mozjs/wrapper_private.h" |
| #include "cobalt/script/property_enumerator.h" |
| #include "third_party/mozjs/js/src/jsapi.h" |
| #include "third_party/mozjs/js/src/jsfriendapi.h" |
| |
| namespace { |
| using cobalt::bindings::testing::OperationsTestInterface; |
| using cobalt::bindings::testing::MozjsOperationsTestInterface; |
| using cobalt::bindings::testing::ArbitraryInterface; |
| using cobalt::bindings::testing::MozjsArbitraryInterface; |
| using cobalt::script::CallbackInterfaceTraits; |
| using cobalt::script::GlobalEnvironment; |
| using cobalt::script::OpaqueHandle; |
| using cobalt::script::OpaqueHandleHolder; |
| using cobalt::script::ScriptObject; |
| using cobalt::script::Wrappable; |
| |
| using cobalt::script::CallbackFunction; |
| using cobalt::script::CallbackInterfaceTraits; |
| using cobalt::script::ExceptionState; |
| using cobalt::script::mozjs::FromJSValue; |
| using cobalt::script::mozjs::kConversionFlagNullable; |
| using cobalt::script::mozjs::kConversionFlagRestricted; |
| using cobalt::script::mozjs::kConversionFlagTreatNullAsEmptyString; |
| using cobalt::script::mozjs::kConversionFlagTreatUndefinedAsEmptyString; |
| using cobalt::script::mozjs::kNoConversionFlags; |
| using cobalt::script::mozjs::InterfaceData; |
| using cobalt::script::mozjs::MozjsCallbackFunction; |
| using cobalt::script::mozjs::MozjsExceptionState; |
| using cobalt::script::mozjs::MozjsGlobalEnvironment; |
| using cobalt::script::mozjs::MozjsUserObjectHolder; |
| using cobalt::script::mozjs::MozjsPropertyEnumerator; |
| using cobalt::script::mozjs::ProxyHandler; |
| using cobalt::script::mozjs::ToJSValue; |
| using cobalt::script::mozjs::TypeTraits; |
| using cobalt::script::mozjs::WrapperPrivate; |
| using cobalt::script::mozjs::WrapperFactory; |
| using cobalt::script::Wrappable; |
| } // namespace |
| |
| namespace cobalt { |
| namespace bindings { |
| namespace testing { |
| |
| namespace { |
| |
| class MozjsOperationsTestInterfaceHandler : public ProxyHandler { |
| public: |
| MozjsOperationsTestInterfaceHandler() |
| : ProxyHandler(indexed_property_hooks, named_property_hooks) {} |
| |
| private: |
| static NamedPropertyHooks named_property_hooks; |
| static IndexedPropertyHooks indexed_property_hooks; |
| }; |
| |
| ProxyHandler::NamedPropertyHooks |
| MozjsOperationsTestInterfaceHandler::named_property_hooks = { |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| }; |
| ProxyHandler::IndexedPropertyHooks |
| MozjsOperationsTestInterfaceHandler::indexed_property_hooks = { |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| }; |
| |
| static base::LazyInstance<MozjsOperationsTestInterfaceHandler> |
| proxy_handler; |
| |
| JSBool HasInstance(JSContext *context, JS::HandleObject type, |
| JS::MutableHandleValue vp, JSBool *success) { |
| JS::RootedObject global_object( |
| context, JS_GetGlobalForObject(context, type)); |
| DCHECK(global_object); |
| |
| JS::RootedObject prototype( |
| context, MozjsOperationsTestInterface::GetPrototype(context, global_object)); |
| |
| // |IsDelegate| walks the prototype chain of an object returning true if |
| // .prototype is found. |
| bool is_delegate; |
| if (!IsDelegate(context, prototype, vp, &is_delegate)) { |
| *success = false; |
| return false; |
| } |
| |
| *success = is_delegate; |
| return true; |
| } |
| |
| InterfaceData* CreateCachedInterfaceData() { |
| InterfaceData* interface_data = new InterfaceData(); |
| memset(&interface_data->instance_class_definition, 0, |
| sizeof(interface_data->instance_class_definition)); |
| memset(&interface_data->prototype_class_definition, 0, |
| sizeof(interface_data->prototype_class_definition)); |
| memset(&interface_data->interface_object_class_definition, 0, |
| sizeof(interface_data->interface_object_class_definition)); |
| |
| JSClass* instance_class = &interface_data->instance_class_definition; |
| const int kGlobalFlags = 0; |
| instance_class->name = "OperationsTestInterface"; |
| instance_class->flags = kGlobalFlags | JSCLASS_HAS_PRIVATE; |
| instance_class->addProperty = JS_PropertyStub; |
| instance_class->delProperty = JS_DeletePropertyStub; |
| instance_class->getProperty = JS_PropertyStub; |
| instance_class->setProperty = JS_StrictPropertyStub; |
| instance_class->enumerate = JS_EnumerateStub; |
| instance_class->resolve = JS_ResolveStub; |
| instance_class->convert = JS_ConvertStub; |
| // Function to be called before on object of this class is garbage collected. |
| instance_class->finalize = &WrapperPrivate::Finalizer; |
| // Called to trace objects that can be referenced from this object. |
| instance_class->trace = &WrapperPrivate::Trace; |
| |
| JSClass* prototype_class = &interface_data->prototype_class_definition; |
| prototype_class->name = "OperationsTestInterfacePrototype"; |
| prototype_class->flags = 0; |
| prototype_class->addProperty = JS_PropertyStub; |
| prototype_class->delProperty = JS_DeletePropertyStub; |
| prototype_class->getProperty = JS_PropertyStub; |
| prototype_class->setProperty = JS_StrictPropertyStub; |
| prototype_class->enumerate = JS_EnumerateStub; |
| prototype_class->resolve = JS_ResolveStub; |
| prototype_class->convert = JS_ConvertStub; |
| |
| JSClass* interface_object_class = |
| &interface_data->interface_object_class_definition; |
| interface_object_class->name = "OperationsTestInterfaceConstructor"; |
| interface_object_class->flags = 0; |
| interface_object_class->addProperty = JS_PropertyStub; |
| interface_object_class->delProperty = JS_DeletePropertyStub; |
| interface_object_class->getProperty = JS_PropertyStub; |
| interface_object_class->setProperty = JS_StrictPropertyStub; |
| interface_object_class->enumerate = JS_EnumerateStub; |
| interface_object_class->resolve = JS_ResolveStub; |
| interface_object_class->convert = JS_ConvertStub; |
| interface_object_class->hasInstance = &HasInstance; |
| return interface_data; |
| } |
| |
| JSBool fcn_longFunctionNoArgs( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->LongFunctionNoArgs(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_objectFunctionNoArgs( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->ObjectFunctionNoArgs(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_optionalArgumentWithDefault( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| // Optional arguments with default values |
| TypeTraits<double >::ConversionType arg1 = |
| 2.718; |
| size_t num_set_arguments = 1; |
| if (args.length() > 0) { |
| JS::RootedValue optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| optional_value0, |
| (kConversionFlagRestricted), |
| &exception_state, |
| &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| } |
| |
| impl->OptionalArgumentWithDefault(arg1); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_optionalArguments( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg1; |
| // Optional arguments |
| TypeTraits<int32_t >::ConversionType arg2; |
| TypeTraits<int32_t >::ConversionType arg3; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| size_t num_set_arguments = 1; |
| if (args.length() > 1) { |
| JS::RootedValue optional_value0( |
| context, args[1]); |
| FromJSValue(context, |
| optional_value0, |
| kNoConversionFlags, |
| &exception_state, |
| &arg2); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| ++num_set_arguments; |
| } |
| if (args.length() > 2) { |
| JS::RootedValue optional_value1( |
| context, args[2]); |
| FromJSValue(context, |
| optional_value1, |
| kNoConversionFlags, |
| &exception_state, |
| &arg3); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| ++num_set_arguments; |
| } |
| switch (num_set_arguments) { |
| case 1: |
| { |
| impl->OptionalArguments(arg1); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| case 2: |
| { |
| impl->OptionalArguments(arg1, arg2); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| case 3: |
| { |
| impl->OptionalArguments(arg1, arg2, arg3); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| JSBool fcn_optionalNullableArgumentsWithDefaults( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| // Optional arguments with default values |
| TypeTraits<base::optional<bool > >::ConversionType arg1 = |
| base::nullopt; |
| TypeTraits<scoped_refptr<ArbitraryInterface> >::ConversionType arg2 = |
| NULL; |
| size_t num_set_arguments = 2; |
| if (args.length() > 0) { |
| JS::RootedValue optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| optional_value0, |
| (kConversionFlagNullable), |
| &exception_state, |
| &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| } |
| if (args.length() > 1) { |
| JS::RootedValue optional_value1( |
| context, args[1]); |
| FromJSValue(context, |
| optional_value1, |
| (kConversionFlagNullable), |
| &exception_state, |
| &arg2); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| } |
| |
| impl->OptionalNullableArgumentsWithDefaults(arg1, arg2); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction1( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| |
| impl->OverloadedFunction(); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction2( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedFunction(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction3( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<std::string >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedFunction(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction4( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 3; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg1; |
| TypeTraits<int32_t >::ConversionType arg2; |
| TypeTraits<int32_t >::ConversionType arg3; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| DCHECK_LT(1, args.length()); |
| JS::RootedValue non_optional_value1( |
| context, args[1]); |
| FromJSValue(context, |
| non_optional_value1, |
| kNoConversionFlags, |
| &exception_state, &arg2); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| DCHECK_LT(2, args.length()); |
| JS::RootedValue non_optional_value2( |
| context, args[2]); |
| FromJSValue(context, |
| non_optional_value2, |
| kNoConversionFlags, |
| &exception_state, &arg3); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedFunction(arg1, arg2, arg3); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction5( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 3; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg1; |
| TypeTraits<int32_t >::ConversionType arg2; |
| TypeTraits<scoped_refptr<ArbitraryInterface> >::ConversionType arg3; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| DCHECK_LT(1, args.length()); |
| JS::RootedValue non_optional_value1( |
| context, args[1]); |
| FromJSValue(context, |
| non_optional_value1, |
| kNoConversionFlags, |
| &exception_state, &arg2); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| DCHECK_LT(2, args.length()); |
| JS::RootedValue non_optional_value2( |
| context, args[2]); |
| FromJSValue(context, |
| non_optional_value2, |
| kNoConversionFlags, |
| &exception_state, &arg3); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedFunction(arg1, arg2, arg3); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedFunction( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| switch(argc) { |
| case(0): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| if (true) { |
| return fcn_overloadedFunction1( |
| context, argc, vp); |
| } |
| break; |
| } |
| case(1): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| JS::RootedValue arg(context, args[0]); |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (arg.isNumber()) { |
| return fcn_overloadedFunction2( |
| context, argc, vp); |
| } |
| if (true) { |
| return fcn_overloadedFunction3( |
| context, argc, vp); |
| } |
| if (true) { |
| return fcn_overloadedFunction2( |
| context, argc, vp); |
| } |
| break; |
| } |
| case(3): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| JS::RootedValue arg(context, args[2]); |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (arg.isObject() ? wrapper_factory->DoesObjectImplementInterface( |
| JSVAL_TO_OBJECT(arg), base::GetTypeId<ArbitraryInterface>()) : |
| false) { |
| return fcn_overloadedFunction5( |
| context, argc, vp); |
| } |
| if (true) { |
| return fcn_overloadedFunction4( |
| context, argc, vp); |
| } |
| break; |
| } |
| } |
| // Invalid number of args |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| // 4. If S is empty, then throw a TypeError. |
| MozjsExceptionState exception_state(context); |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| |
| JSBool fcn_overloadedNullable1( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedNullable(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedNullable2( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<base::optional<bool > >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| (kConversionFlagNullable), |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->OverloadedNullable(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_overloadedNullable( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| switch(argc) { |
| case(1): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| JS::RootedValue arg(context, args[0]); |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (arg.isNullOrUndefined()) { |
| return fcn_overloadedNullable2( |
| context, argc, vp); |
| } |
| if (true) { |
| return fcn_overloadedNullable1( |
| context, argc, vp); |
| } |
| break; |
| } |
| } |
| // Invalid number of args |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| // 4. If S is empty, then throw a TypeError. |
| MozjsExceptionState exception_state(context); |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| |
| JSBool fcn_stringFunctionNoArgs( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->StringFunctionNoArgs(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_variadicPrimitiveArguments( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| // Variadic argument |
| TypeTraits<std::vector<int32_t> >::ConversionType bools; |
| |
| // Get variadic arguments. |
| const size_t kFirstVariadicArgIndex = 0; |
| if (args.length() > kFirstVariadicArgIndex) { |
| bools.resize(args.length() - kFirstVariadicArgIndex); |
| for (int i = 0; i + kFirstVariadicArgIndex < args.length(); ++i) { |
| JS::RootedValue variadic_argument_value( |
| context, args[i + kFirstVariadicArgIndex]); |
| FromJSValue(context, |
| variadic_argument_value, |
| kNoConversionFlags, |
| &exception_state, |
| &bools[i]); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| } |
| } |
| |
| impl->VariadicPrimitiveArguments(bools); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_variadicStringArgumentsAfterOptionalArgument( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| // Optional arguments |
| TypeTraits<bool >::ConversionType optional_arg; |
| // Variadic argument |
| TypeTraits<std::vector<std::string> >::ConversionType strings; |
| size_t num_set_arguments = 0; |
| if (args.length() > 0) { |
| JS::RootedValue optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| optional_value0, |
| kNoConversionFlags, |
| &exception_state, |
| &optional_arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| ++num_set_arguments; |
| } |
| |
| // Get variadic arguments. |
| const size_t kLastOptionalArgIndex = 1; |
| if (num_set_arguments == kLastOptionalArgIndex) { |
| // If the last optional argument has been set, we will call the overload |
| // that takes the variadic argument, possibly with an empty vector in the |
| // case that there are no more arguments left. |
| ++num_set_arguments; |
| } |
| const size_t kFirstVariadicArgIndex = 1; |
| if (args.length() > kFirstVariadicArgIndex) { |
| strings.resize(args.length() - kFirstVariadicArgIndex); |
| for (int i = 0; i + kFirstVariadicArgIndex < args.length(); ++i) { |
| JS::RootedValue variadic_argument_value( |
| context, args[i + kFirstVariadicArgIndex]); |
| FromJSValue(context, |
| variadic_argument_value, |
| kNoConversionFlags, |
| &exception_state, |
| &strings[i]); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| } |
| } |
| switch (num_set_arguments) { |
| case 0: |
| { |
| impl->VariadicStringArgumentsAfterOptionalArgument(); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| case 2: |
| { |
| impl->VariadicStringArgumentsAfterOptionalArgument(optional_arg, strings); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| JSBool fcn_voidFunctionLongArg( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<int32_t >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->VoidFunctionLongArg(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_voidFunctionNoArgs( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| |
| impl->VoidFunctionNoArgs(); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_voidFunctionObjectArg( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<scoped_refptr<ArbitraryInterface> >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->VoidFunctionObjectArg(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool fcn_voidFunctionStringArg( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| // Compute the 'this' value. |
| JS::RootedValue this_value(context, JS_ComputeThis(context, vp)); |
| // 'this' should be an object. |
| JS::RootedObject object(context); |
| if (JS_TypeOfValue(context, this_value) != JSTYPE_OBJECT) { |
| NOTREACHED(); |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, object.address())) { |
| NOTREACHED(); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| OperationsTestInterface* impl = |
| wrapper_private->wrappable<OperationsTestInterface>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<std::string >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->VoidFunctionStringArg(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool staticfcn_overloadedFunction1( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<double >::ConversionType arg; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| (kConversionFlagRestricted), |
| &exception_state, &arg); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| OperationsTestInterface::OverloadedFunction(arg); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool staticfcn_overloadedFunction2( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| const size_t kMinArguments = 2; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<double >::ConversionType arg1; |
| TypeTraits<double >::ConversionType arg2; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| (kConversionFlagRestricted), |
| &exception_state, &arg1); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| DCHECK_LT(1, args.length()); |
| JS::RootedValue non_optional_value1( |
| context, args[1]); |
| FromJSValue(context, |
| non_optional_value1, |
| (kConversionFlagRestricted), |
| &exception_state, &arg2); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| OperationsTestInterface::OverloadedFunction(arg1, arg2); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| JSBool staticfcn_overloadedFunction( |
| JSContext* context, uint32_t argc, JS::Value *vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| switch(argc) { |
| case(1): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| if (true) { |
| return staticfcn_overloadedFunction1( |
| context, argc, vp); |
| } |
| break; |
| } |
| case(2): { |
| // Overload resolution algorithm details found here: |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| if (true) { |
| return staticfcn_overloadedFunction2( |
| context, argc, vp); |
| } |
| break; |
| } |
| } |
| // Invalid number of args |
| // http://heycam.github.io/webidl/#dfn-overload-resolution-algorithm |
| // 4. If S is empty, then throw a TypeError. |
| MozjsExceptionState exception_state(context); |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| |
| |
| const JSPropertySpec prototype_properties[] = { |
| JS_PS_END |
| }; |
| |
| const JSFunctionSpec prototype_functions[] = { |
| { |
| "longFunctionNoArgs", |
| JSOP_WRAPPER(&fcn_longFunctionNoArgs), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "objectFunctionNoArgs", |
| JSOP_WRAPPER(&fcn_objectFunctionNoArgs), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "optionalArgumentWithDefault", |
| JSOP_WRAPPER(&fcn_optionalArgumentWithDefault), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "optionalArguments", |
| JSOP_WRAPPER(&fcn_optionalArguments), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "optionalNullableArgumentsWithDefaults", |
| JSOP_WRAPPER(&fcn_optionalNullableArgumentsWithDefaults), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "overloadedFunction", |
| JSOP_WRAPPER(&fcn_overloadedFunction), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "overloadedNullable", |
| JSOP_WRAPPER(&fcn_overloadedNullable), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "stringFunctionNoArgs", |
| JSOP_WRAPPER(&fcn_stringFunctionNoArgs), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "variadicPrimitiveArguments", |
| JSOP_WRAPPER(&fcn_variadicPrimitiveArguments), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "variadicStringArgumentsAfterOptionalArgument", |
| JSOP_WRAPPER(&fcn_variadicStringArgumentsAfterOptionalArgument), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "voidFunctionLongArg", |
| JSOP_WRAPPER(&fcn_voidFunctionLongArg), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "voidFunctionNoArgs", |
| JSOP_WRAPPER(&fcn_voidFunctionNoArgs), |
| 0, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "voidFunctionObjectArg", |
| JSOP_WRAPPER(&fcn_voidFunctionObjectArg), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| { |
| "voidFunctionStringArg", |
| JSOP_WRAPPER(&fcn_voidFunctionStringArg), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| JS_FS_END |
| }; |
| |
| const JSPropertySpec interface_object_properties[] = { |
| JS_PS_END |
| }; |
| |
| const JSFunctionSpec interface_object_functions[] = { |
| { |
| "overloadedFunction", |
| JSOP_WRAPPER(&staticfcn_overloadedFunction), |
| 1, |
| JSPROP_ENUMERATE, |
| NULL, |
| }, |
| JS_FS_END |
| }; |
| |
| const JSPropertySpec own_properties[] = { |
| JS_PS_END |
| }; |
| |
| void InitializePrototypeAndInterfaceObject( |
| InterfaceData* interface_data, JSContext* context, |
| JS::HandleObject global_object) { |
| DCHECK(!interface_data->prototype); |
| DCHECK(!interface_data->interface_object); |
| DCHECK(JS_IsGlobalObject(global_object)); |
| |
| JS::RootedObject parent_prototype( |
| context, JS_GetObjectPrototype(context, global_object)); |
| DCHECK(parent_prototype); |
| |
| // Create the Prototype object. |
| interface_data->prototype = JS_NewObjectWithGivenProto( |
| context, &interface_data->prototype_class_definition, parent_prototype, |
| NULL); |
| bool success = JS_DefineProperties( |
| context, interface_data->prototype, prototype_properties); |
| DCHECK(success); |
| success = JS_DefineFunctions( |
| context, interface_data->prototype, prototype_functions); |
| DCHECK(success); |
| |
| JS::RootedObject function_prototype( |
| context, JS_GetFunctionPrototype(context, global_object)); |
| DCHECK(function_prototype); |
| // Create the Interface object. |
| interface_data->interface_object = JS_NewObjectWithGivenProto( |
| context, &interface_data->interface_object_class_definition, |
| function_prototype, NULL); |
| |
| // Add the InterfaceObject.name property. |
| JS::RootedObject rooted_interface_object( |
| context, interface_data->interface_object); |
| JS::RootedValue name_value(context); |
| const char name[] = |
| "OperationsTestInterface"; |
| name_value.setString(JS_NewStringCopyZ(context, name)); |
| success = |
| JS_DefineProperty(context, rooted_interface_object, "name", name_value, |
| JS_PropertyStub, JS_StrictPropertyStub, |
| JSPROP_READONLY); |
| DCHECK(success); |
| |
| // Define interface object properties (including constants). |
| success = JS_DefineProperties(context, rooted_interface_object, |
| interface_object_properties); |
| DCHECK(success); |
| // Define interface object functions (static). |
| success = JS_DefineFunctions(context, rooted_interface_object, |
| interface_object_functions); |
| DCHECK(success); |
| |
| |
| // Set the Prototype.constructor and Constructor.prototype properties. |
| DCHECK(interface_data->interface_object); |
| DCHECK(interface_data->prototype); |
| JS::RootedObject rooted_prototype(context, interface_data->prototype); |
| success = JS_LinkConstructorAndPrototype( |
| context, |
| rooted_interface_object, |
| rooted_prototype); |
| DCHECK(success); |
| } |
| |
| InterfaceData* GetInterfaceData(JSContext* context) { |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| // Use the address of the properties definition for this interface as a |
| // unique key for looking up the InterfaceData for this interface. |
| intptr_t key = reinterpret_cast<intptr_t>(&own_properties); |
| InterfaceData* interface_data = global_environment->GetInterfaceData(key); |
| if (!interface_data) { |
| interface_data = CreateCachedInterfaceData(); |
| DCHECK(interface_data); |
| global_environment->CacheInterfaceData(key, interface_data); |
| DCHECK_EQ(interface_data, global_environment->GetInterfaceData(key)); |
| } |
| return interface_data; |
| } |
| |
| } // namespace |
| |
| // static |
| JSObject* MozjsOperationsTestInterface::CreateProxy( |
| JSContext* context, const scoped_refptr<Wrappable>& wrappable) { |
| DCHECK(MozjsGlobalEnvironment::GetFromContext(context)); |
| JS::RootedObject global_object( |
| context, |
| MozjsGlobalEnvironment::GetFromContext(context)->global_object()); |
| DCHECK(global_object); |
| |
| InterfaceData* interface_data = GetInterfaceData(context); |
| JS::RootedObject prototype(context, GetPrototype(context, global_object)); |
| DCHECK(prototype); |
| JS::RootedObject new_object(context, JS_NewObjectWithGivenProto( |
| context, &interface_data->instance_class_definition, prototype, NULL)); |
| DCHECK(new_object); |
| JS::RootedObject proxy(context, |
| ProxyHandler::NewProxy(context, new_object, prototype, NULL, |
| proxy_handler.Pointer())); |
| WrapperPrivate::AddPrivateData(context, proxy, wrappable); |
| return proxy; |
| } |
| |
| //static |
| const JSClass* MozjsOperationsTestInterface::PrototypeClass( |
| JSContext* context) { |
| DCHECK(MozjsGlobalEnvironment::GetFromContext(context)); |
| JS::RootedObject global_object( |
| context, |
| MozjsGlobalEnvironment::GetFromContext(context)->global_object()); |
| DCHECK(global_object); |
| |
| JS::RootedObject prototype(context, GetPrototype(context, global_object)); |
| JSClass* proto_class = JS_GetClass(*prototype.address()); |
| return proto_class; |
| } |
| |
| // static |
| JSObject* MozjsOperationsTestInterface::GetPrototype( |
| JSContext* context, JS::HandleObject global_object) { |
| DCHECK(JS_IsGlobalObject(global_object)); |
| |
| InterfaceData* interface_data = GetInterfaceData(context); |
| if (!interface_data->prototype) { |
| // Create new prototype that has all the props and methods |
| InitializePrototypeAndInterfaceObject( |
| interface_data, context, global_object); |
| } |
| DCHECK(interface_data->prototype); |
| return interface_data->prototype; |
| } |
| |
| // static |
| JSObject* MozjsOperationsTestInterface::GetInterfaceObject( |
| JSContext* context, JS::HandleObject global_object) { |
| DCHECK(JS_IsGlobalObject(global_object)); |
| |
| InterfaceData* interface_data = GetInterfaceData(context); |
| if (!interface_data->interface_object) { |
| InitializePrototypeAndInterfaceObject( |
| interface_data, context, global_object); |
| } |
| DCHECK(interface_data->interface_object); |
| return interface_data->interface_object; |
| } |
| |
| |
| namespace { |
| } // namespace |
| |
| |
| } // namespace testing |
| } // namespace bindings |
| } // namespace cobalt |