| // Copyright 2017 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. |
| |
| // clang-format off |
| |
| // This file has been auto-generated by bindings/code_generator_cobalt.py. DO NOT MODIFY! |
| // Auto-generated from template: bindings/mozjs45/templates/interface.cc.template |
| |
| #include "cobalt/bindings/testing/mozjs_window.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_value.h" |
| #include "cobalt/bindings/testing/anonymous_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/anonymous_named_getter_interface.h" |
| #include "cobalt/bindings/testing/anonymous_named_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/arbitrary_interface.h" |
| #include "cobalt/bindings/testing/base_interface.h" |
| #include "cobalt/bindings/testing/boolean_type_test_interface.h" |
| #include "cobalt/bindings/testing/callback_function_interface.h" |
| #include "cobalt/bindings/testing/callback_interface_interface.h" |
| #include "cobalt/bindings/testing/conditional_interface.h" |
| #include "cobalt/bindings/testing/constants_interface.h" |
| #include "cobalt/bindings/testing/constructor_interface.h" |
| #include "cobalt/bindings/testing/constructor_with_arguments_interface.h" |
| #include "cobalt/bindings/testing/derived_getter_setter_interface.h" |
| #include "cobalt/bindings/testing/derived_interface.h" |
| #include "cobalt/bindings/testing/dictionary_interface.h" |
| #include "cobalt/bindings/testing/disabled_interface.h" |
| #include "cobalt/bindings/testing/dom_string_test_interface.h" |
| #include "cobalt/bindings/testing/enumeration_interface.h" |
| #include "cobalt/bindings/testing/exception_object_interface.h" |
| #include "cobalt/bindings/testing/exceptions_interface.h" |
| #include "cobalt/bindings/testing/extended_idl_attributes_interface.h" |
| #include "cobalt/bindings/testing/garbage_collection_test_interface.h" |
| #include "cobalt/bindings/testing/global_interface_parent.h" |
| #include "cobalt/bindings/testing/implemented_interface.h" |
| #include "cobalt/bindings/testing/indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/interface_with_any.h" |
| #include "cobalt/bindings/testing/interface_with_any_dictionary.h" |
| #include "cobalt/bindings/testing/interface_with_unsupported_properties.h" |
| #include "cobalt/bindings/testing/mozjs_anonymous_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_anonymous_named_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_anonymous_named_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_arbitrary_interface.h" |
| #include "cobalt/bindings/testing/mozjs_base_interface.h" |
| #include "cobalt/bindings/testing/mozjs_boolean_type_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_callback_function_interface.h" |
| #include "cobalt/bindings/testing/mozjs_callback_interface_interface.h" |
| #include "cobalt/bindings/testing/mozjs_conditional_interface.h" |
| #include "cobalt/bindings/testing/mozjs_constants_interface.h" |
| #include "cobalt/bindings/testing/mozjs_constructor_interface.h" |
| #include "cobalt/bindings/testing/mozjs_constructor_with_arguments_interface.h" |
| #include "cobalt/bindings/testing/mozjs_derived_getter_setter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_derived_interface.h" |
| #include "cobalt/bindings/testing/mozjs_dictionary_interface.h" |
| #include "cobalt/bindings/testing/mozjs_disabled_interface.h" |
| #include "cobalt/bindings/testing/mozjs_dom_string_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_enumeration_interface.h" |
| #include "cobalt/bindings/testing/mozjs_exception_object_interface.h" |
| #include "cobalt/bindings/testing/mozjs_exceptions_interface.h" |
| #include "cobalt/bindings/testing/mozjs_extended_idl_attributes_interface.h" |
| #include "cobalt/bindings/testing/mozjs_garbage_collection_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_global_interface_parent.h" |
| #include "cobalt/bindings/testing/mozjs_implemented_interface.h" |
| #include "cobalt/bindings/testing/mozjs_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_interface_with_any.h" |
| #include "cobalt/bindings/testing/mozjs_interface_with_any_dictionary.h" |
| #include "cobalt/bindings/testing/mozjs_interface_with_unsupported_properties.h" |
| #include "cobalt/bindings/testing/mozjs_named_constructor_interface.h" |
| #include "cobalt/bindings/testing/mozjs_named_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_named_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/mozjs_nested_put_forwards_interface.h" |
| #include "cobalt/bindings/testing/mozjs_no_constructor_interface.h" |
| #include "cobalt/bindings/testing/mozjs_no_interface_object_interface.h" |
| #include "cobalt/bindings/testing/mozjs_nullable_types_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_numeric_types_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_object_type_bindings_interface.h" |
| #include "cobalt/bindings/testing/mozjs_operations_test_interface.h" |
| #include "cobalt/bindings/testing/mozjs_promise_interface.h" |
| #include "cobalt/bindings/testing/mozjs_put_forwards_interface.h" |
| #include "cobalt/bindings/testing/mozjs_sequence_user.h" |
| #include "cobalt/bindings/testing/mozjs_single_operation_interface.h" |
| #include "cobalt/bindings/testing/mozjs_static_properties_interface.h" |
| #include "cobalt/bindings/testing/mozjs_stringifier_anonymous_operation_interface.h" |
| #include "cobalt/bindings/testing/mozjs_stringifier_attribute_interface.h" |
| #include "cobalt/bindings/testing/mozjs_stringifier_operation_interface.h" |
| #include "cobalt/bindings/testing/mozjs_target_interface.h" |
| #include "cobalt/bindings/testing/mozjs_union_types_interface.h" |
| #include "cobalt/bindings/testing/mozjs_window.h" |
| #include "cobalt/bindings/testing/named_constructor_interface.h" |
| #include "cobalt/bindings/testing/named_getter_interface.h" |
| #include "cobalt/bindings/testing/named_indexed_getter_interface.h" |
| #include "cobalt/bindings/testing/nested_put_forwards_interface.h" |
| #include "cobalt/bindings/testing/no_constructor_interface.h" |
| #include "cobalt/bindings/testing/no_interface_object_interface.h" |
| #include "cobalt/bindings/testing/nullable_types_test_interface.h" |
| #include "cobalt/bindings/testing/numeric_types_test_interface.h" |
| #include "cobalt/bindings/testing/object_type_bindings_interface.h" |
| #include "cobalt/bindings/testing/operations_test_interface.h" |
| #include "cobalt/bindings/testing/promise_interface.h" |
| #include "cobalt/bindings/testing/put_forwards_interface.h" |
| #include "cobalt/bindings/testing/sequence_user.h" |
| #include "cobalt/bindings/testing/single_operation_interface.h" |
| #include "cobalt/bindings/testing/static_properties_interface.h" |
| #include "cobalt/bindings/testing/stringifier_anonymous_operation_interface.h" |
| #include "cobalt/bindings/testing/stringifier_attribute_interface.h" |
| #include "cobalt/bindings/testing/stringifier_operation_interface.h" |
| #include "cobalt/bindings/testing/target_interface.h" |
| #include "cobalt/bindings/testing/union_types_interface.h" |
| #include "cobalt/bindings/testing/window.h" |
| |
| #include "mozjs_gen_type_conversion.h" |
| |
| #include "base/lazy_instance.h" |
| #include "cobalt/script/exception_state.h" |
| #include "cobalt/script/mozjs-45/callback_function_conversion.h" |
| #include "cobalt/script/mozjs-45/conversion_helpers.h" |
| #include "cobalt/script/mozjs-45/mozjs_callback_function.h" |
| #include "cobalt/script/mozjs-45/mozjs_exception_state.h" |
| #include "cobalt/script/mozjs-45/mozjs_global_environment.h" |
| #include "cobalt/script/mozjs-45/mozjs_object_handle.h" |
| #include "cobalt/script/mozjs-45/mozjs_property_enumerator.h" |
| #include "cobalt/script/mozjs-45/mozjs_user_object_holder.h" |
| #include "cobalt/script/mozjs-45/mozjs_value_handle.h" |
| #include "cobalt/script/mozjs-45/native_promise.h" |
| #include "cobalt/script/mozjs-45/proxy_handler.h" |
| #include "cobalt/script/mozjs-45/type_traits.h" |
| #include "cobalt/script/mozjs-45/wrapper_factory.h" |
| #include "cobalt/script/mozjs-45/wrapper_private.h" |
| #include "cobalt/script/property_enumerator.h" |
| #include "cobalt/script/sequence.h" |
| #include "third_party/mozjs-45/js/src/jsapi.h" |
| #include "third_party/mozjs-45/js/src/jsfriendapi.h" |
| |
| namespace { |
| using cobalt::bindings::testing::Window; |
| using cobalt::bindings::testing::MozjsWindow; |
| using cobalt::bindings::testing::AnonymousIndexedGetterInterface; |
| using cobalt::bindings::testing::AnonymousNamedGetterInterface; |
| using cobalt::bindings::testing::AnonymousNamedIndexedGetterInterface; |
| using cobalt::bindings::testing::ArbitraryInterface; |
| using cobalt::bindings::testing::BaseInterface; |
| using cobalt::bindings::testing::BooleanTypeTestInterface; |
| using cobalt::bindings::testing::CallbackFunctionInterface; |
| using cobalt::bindings::testing::CallbackInterfaceInterface; |
| #if defined(ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::ConditionalInterface; |
| #endif // defined(ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::ConstantsInterface; |
| using cobalt::bindings::testing::ConstructorInterface; |
| using cobalt::bindings::testing::ConstructorWithArgumentsInterface; |
| using cobalt::bindings::testing::DOMStringTestInterface; |
| using cobalt::bindings::testing::DerivedGetterSetterInterface; |
| using cobalt::bindings::testing::DerivedInterface; |
| using cobalt::bindings::testing::DictionaryInterface; |
| #if defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::DisabledInterface; |
| #endif // defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::EnumerationInterface; |
| using cobalt::bindings::testing::ExceptionObjectInterface; |
| using cobalt::bindings::testing::ExceptionsInterface; |
| using cobalt::bindings::testing::ExtendedIDLAttributesInterface; |
| using cobalt::bindings::testing::GarbageCollectionTestInterface; |
| using cobalt::bindings::testing::GlobalInterfaceParent; |
| using cobalt::bindings::testing::ImplementedInterface; |
| using cobalt::bindings::testing::IndexedGetterInterface; |
| using cobalt::bindings::testing::InterfaceWithAny; |
| using cobalt::bindings::testing::InterfaceWithAnyDictionary; |
| using cobalt::bindings::testing::InterfaceWithUnsupportedProperties; |
| using cobalt::bindings::testing::MozjsAnonymousIndexedGetterInterface; |
| using cobalt::bindings::testing::MozjsAnonymousNamedGetterInterface; |
| using cobalt::bindings::testing::MozjsAnonymousNamedIndexedGetterInterface; |
| using cobalt::bindings::testing::MozjsArbitraryInterface; |
| using cobalt::bindings::testing::MozjsBaseInterface; |
| using cobalt::bindings::testing::MozjsBooleanTypeTestInterface; |
| using cobalt::bindings::testing::MozjsCallbackFunctionInterface; |
| using cobalt::bindings::testing::MozjsCallbackInterfaceInterface; |
| #if defined(ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::MozjsConditionalInterface; |
| #endif // defined(ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::MozjsConstantsInterface; |
| using cobalt::bindings::testing::MozjsConstructorInterface; |
| using cobalt::bindings::testing::MozjsConstructorWithArgumentsInterface; |
| using cobalt::bindings::testing::MozjsDOMStringTestInterface; |
| using cobalt::bindings::testing::MozjsDerivedGetterSetterInterface; |
| using cobalt::bindings::testing::MozjsDerivedInterface; |
| using cobalt::bindings::testing::MozjsDictionaryInterface; |
| #if defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::MozjsDisabledInterface; |
| #endif // defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| using cobalt::bindings::testing::MozjsEnumerationInterface; |
| using cobalt::bindings::testing::MozjsExceptionObjectInterface; |
| using cobalt::bindings::testing::MozjsExceptionsInterface; |
| using cobalt::bindings::testing::MozjsExtendedIDLAttributesInterface; |
| using cobalt::bindings::testing::MozjsGarbageCollectionTestInterface; |
| using cobalt::bindings::testing::MozjsGlobalInterfaceParent; |
| using cobalt::bindings::testing::MozjsImplementedInterface; |
| using cobalt::bindings::testing::MozjsIndexedGetterInterface; |
| using cobalt::bindings::testing::MozjsInterfaceWithAny; |
| using cobalt::bindings::testing::MozjsInterfaceWithAnyDictionary; |
| using cobalt::bindings::testing::MozjsInterfaceWithUnsupportedProperties; |
| using cobalt::bindings::testing::MozjsNamedConstructorInterface; |
| using cobalt::bindings::testing::MozjsNamedGetterInterface; |
| using cobalt::bindings::testing::MozjsNamedIndexedGetterInterface; |
| using cobalt::bindings::testing::MozjsNestedPutForwardsInterface; |
| using cobalt::bindings::testing::MozjsNoConstructorInterface; |
| using cobalt::bindings::testing::MozjsNoInterfaceObjectInterface; |
| using cobalt::bindings::testing::MozjsNullableTypesTestInterface; |
| using cobalt::bindings::testing::MozjsNumericTypesTestInterface; |
| using cobalt::bindings::testing::MozjsObjectTypeBindingsInterface; |
| using cobalt::bindings::testing::MozjsOperationsTestInterface; |
| using cobalt::bindings::testing::MozjsPromiseInterface; |
| using cobalt::bindings::testing::MozjsPutForwardsInterface; |
| using cobalt::bindings::testing::MozjsSequenceUser; |
| using cobalt::bindings::testing::MozjsSingleOperationInterface; |
| using cobalt::bindings::testing::MozjsStaticPropertiesInterface; |
| using cobalt::bindings::testing::MozjsStringifierAnonymousOperationInterface; |
| using cobalt::bindings::testing::MozjsStringifierAttributeInterface; |
| using cobalt::bindings::testing::MozjsStringifierOperationInterface; |
| using cobalt::bindings::testing::MozjsTargetInterface; |
| using cobalt::bindings::testing::MozjsUnionTypesInterface; |
| using cobalt::bindings::testing::MozjsWindow; |
| using cobalt::bindings::testing::NamedConstructorInterface; |
| using cobalt::bindings::testing::NamedGetterInterface; |
| using cobalt::bindings::testing::NamedIndexedGetterInterface; |
| using cobalt::bindings::testing::NestedPutForwardsInterface; |
| using cobalt::bindings::testing::NoConstructorInterface; |
| using cobalt::bindings::testing::NoInterfaceObjectInterface; |
| using cobalt::bindings::testing::NullableTypesTestInterface; |
| using cobalt::bindings::testing::NumericTypesTestInterface; |
| using cobalt::bindings::testing::ObjectTypeBindingsInterface; |
| using cobalt::bindings::testing::OperationsTestInterface; |
| using cobalt::bindings::testing::PromiseInterface; |
| using cobalt::bindings::testing::PutForwardsInterface; |
| using cobalt::bindings::testing::SequenceUser; |
| using cobalt::bindings::testing::SingleOperationInterface; |
| using cobalt::bindings::testing::StaticPropertiesInterface; |
| using cobalt::bindings::testing::StringifierAnonymousOperationInterface; |
| using cobalt::bindings::testing::StringifierAttributeInterface; |
| using cobalt::bindings::testing::StringifierOperationInterface; |
| using cobalt::bindings::testing::TargetInterface; |
| using cobalt::bindings::testing::UnionTypesInterface; |
| using cobalt::bindings::testing::Window; |
| using cobalt::script::CallbackInterfaceTraits; |
| using cobalt::script::GlobalEnvironment; |
| using cobalt::script::OpaqueHandle; |
| using cobalt::script::OpaqueHandleHolder; |
| using cobalt::script::ScriptValue; |
| using cobalt::script::ValueHandle; |
| using cobalt::script::Wrappable; |
| |
| using cobalt::script::CallbackFunction; |
| using cobalt::script::CallbackInterfaceTraits; |
| using cobalt::script::ExceptionState; |
| using cobalt::script::Wrappable; |
| using cobalt::script::mozjs::FromJSValue; |
| using cobalt::script::mozjs::InterfaceData; |
| using cobalt::script::mozjs::MozjsCallbackFunction; |
| using cobalt::script::mozjs::MozjsExceptionState; |
| using cobalt::script::mozjs::MozjsGlobalEnvironment; |
| using cobalt::script::mozjs::MozjsPropertyEnumerator; |
| using cobalt::script::mozjs::MozjsUserObjectHolder; |
| using cobalt::script::mozjs::ProxyHandler; |
| using cobalt::script::mozjs::ToJSValue; |
| using cobalt::script::mozjs::TypeTraits; |
| using cobalt::script::mozjs::WrapperFactory; |
| using cobalt::script::mozjs::WrapperPrivate; |
| using cobalt::script::mozjs::kConversionFlagClamped; |
| 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; |
| JSObject* DummyFunctor( |
| JSContext* context, const scoped_refptr<Wrappable>& wrappable) { |
| NOTREACHED(); |
| return NULL; |
| } |
| } // namespace |
| |
| namespace cobalt { |
| namespace bindings { |
| namespace testing { |
| |
| namespace { |
| |
| class MozjsWindowHandler : public ProxyHandler { |
| public: |
| MozjsWindowHandler() |
| : ProxyHandler(indexed_property_hooks, named_property_hooks) {} |
| |
| private: |
| static NamedPropertyHooks named_property_hooks; |
| static IndexedPropertyHooks indexed_property_hooks; |
| }; |
| |
| ProxyHandler::NamedPropertyHooks |
| MozjsWindowHandler::named_property_hooks = { |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| }; |
| ProxyHandler::IndexedPropertyHooks |
| MozjsWindowHandler::indexed_property_hooks = { |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| }; |
| |
| static base::LazyInstance<MozjsWindowHandler> |
| proxy_handler; |
| |
| bool HasInstance(JSContext *context, JS::HandleObject type, |
| JS::MutableHandleValue vp, bool *success) { |
| JS::RootedObject global_object( |
| context, JS_GetGlobalForObject(context, type)); |
| DCHECK(global_object); |
| |
| JS::RootedObject prototype( |
| context, MozjsWindow::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; |
| } |
| |
| const JSClass instance_class_definition = { |
| "Window", |
| JSCLASS_GLOBAL_FLAGS | JSCLASS_HAS_PRIVATE, |
| NULL, // addProperty |
| NULL, // delProperty |
| NULL, // getProperty |
| NULL, // setProperty |
| NULL, // enumerate |
| NULL, // resolve |
| NULL, // mayResolve |
| &WrapperPrivate::Finalizer, // finalize |
| NULL, // call |
| NULL, // hasInstance |
| NULL, // construct |
| JS_GlobalObjectTraceHook, // trace |
| }; |
| |
| const JSClass prototype_class_definition = { |
| "WindowPrototype", |
| }; |
| |
| const JSClass interface_object_class_definition = { |
| "WindowConstructor", |
| 0, |
| NULL, // addProperty |
| NULL, // delProperty |
| NULL, // getProperty |
| NULL, // setProperty |
| NULL, // enumerate |
| NULL, // resolve |
| NULL, // mayResolve |
| NULL, // finalize |
| NULL, // call |
| &HasInstance, |
| NULL, |
| }; |
| |
| bool get_windowProperty( |
| JSContext* context, unsigned argc, JS::Value* vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| if (!args.thisv().isObject()) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kTypeError, "Invalid this."); |
| return false; |
| } |
| JS::RootedObject object(context, &args.thisv().toObject()); |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->window_property(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| bool set_windowProperty( |
| JSContext* context, unsigned argc, JS::Value* vp) { |
| |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| if (!args.thisv().isObject()) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kTypeError, "Invalid this."); |
| return false; |
| } |
| JS::RootedObject object(context, &args.thisv().toObject()); |
| |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| TypeTraits<std::string >::ConversionType value; |
| if (args.length() != 1) { |
| NOTREACHED(); |
| return false; |
| } |
| FromJSValue(context, args[0], kNoConversionFlags, &exception_state, |
| &value); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->set_window_property(value); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| bool get_window( |
| JSContext* context, unsigned argc, JS::Value* vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| if (!args.thisv().isObject()) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kTypeError, "Invalid this."); |
| return false; |
| } |
| JS::RootedObject object(context, &args.thisv().toObject()); |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->window(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| |
| bool get_onEvent( |
| JSContext* context, unsigned argc, JS::Value* vp) { |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| if (!args.thisv().isObject()) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kTypeError, "Invalid this."); |
| return false; |
| } |
| JS::RootedObject object(context, &args.thisv().toObject()); |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->on_event(), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| bool set_onEvent( |
| JSContext* context, unsigned argc, JS::Value* vp) { |
| |
| JS::CallArgs args = JS::CallArgsFromVp(argc, vp); |
| if (!args.thisv().isObject()) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kTypeError, "Invalid this."); |
| return false; |
| } |
| JS::RootedObject object(context, &args.thisv().toObject()); |
| |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| TypeTraits<::cobalt::script::CallbackInterfaceTraits<SingleOperationInterface > >::ConversionType value; |
| if (args.length() != 1) { |
| NOTREACHED(); |
| return false; |
| } |
| FromJSValue(context, args[0], (kConversionFlagNullable), &exception_state, |
| &value); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| |
| impl->set_on_event(value); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| bool fcn_getStackTrace( |
| 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) { |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, &object)) { |
| NOTREACHED(); |
| return false; |
| } |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| MozjsGlobalEnvironment* callwith_global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->GetStackTrace(callwith_global_environment->GetStackTrace()), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| |
| bool fcn_setTimeout( |
| 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) { |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, &object)) { |
| NOTREACHED(); |
| return false; |
| } |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| const size_t kMinArguments = 1; |
| if (args.length() < kMinArguments) { |
| exception_state.SetSimpleException(script::kInvalidNumberOfArguments); |
| return false; |
| } |
| // Non-optional arguments |
| TypeTraits<Window::TimerCallback >::ConversionType handler; |
| // Optional arguments |
| TypeTraits<int32_t >::ConversionType timeout; |
| |
| DCHECK_LT(0, args.length()); |
| JS::RootedValue non_optional_value0( |
| context, args[0]); |
| FromJSValue(context, |
| non_optional_value0, |
| kNoConversionFlags, |
| &exception_state, &handler); |
| 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, |
| &timeout); |
| if (exception_state.is_exception_set()) { |
| return false; |
| } |
| ++num_set_arguments; |
| } |
| switch (num_set_arguments) { |
| case 1: |
| { |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->SetTimeout(handler), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| case 2: |
| { |
| if (!exception_state.is_exception_set()) { |
| ToJSValue(context, |
| impl->SetTimeout(handler, timeout), |
| &result_value); |
| } |
| if (!exception_state.is_exception_set()) { |
| args.rval().set(result_value); |
| } |
| return !exception_state.is_exception_set(); |
| } |
| break; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| bool fcn_windowOperation( |
| 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) { |
| return false; |
| } |
| if (!JS_ValueToObject(context, this_value, &object)) { |
| NOTREACHED(); |
| return false; |
| } |
| const JSClass* proto_class = |
| MozjsWindow::PrototypeClass(context); |
| if (proto_class == JS_GetClass(object)) { |
| // Simply returns true if the object is this class's prototype object. |
| // There is no need to return any value due to the object is not a platform |
| // object. The execution reaches here when Object.getOwnPropertyDescriptor |
| // gets called on native object prototypes. |
| return true; |
| } |
| |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| WrapperFactory* wrapper_factory = global_environment->wrapper_factory(); |
| if (!wrapper_factory->DoesObjectImplementInterface( |
| object, base::GetTypeId<Window>())) { |
| MozjsExceptionState exception(context); |
| exception.SetSimpleException(script::kDoesNotImplementInterface); |
| return false; |
| } |
| MozjsExceptionState exception_state(context); |
| JS::RootedValue result_value(context); |
| |
| WrapperPrivate* wrapper_private = |
| WrapperPrivate::GetFromObject(context, object); |
| Window* impl = |
| wrapper_private->wrappable<Window>().get(); |
| |
| impl->WindowOperation(); |
| result_value.set(JS::UndefinedHandleValue); |
| return !exception_state.is_exception_set(); |
| } |
| |
| |
| |
| const JSPropertySpec prototype_properties[] = { |
| { // Read/Write property |
| "windowProperty", |
| JSPROP_SHARED | JSPROP_ENUMERATE, |
| { { &get_windowProperty, NULL } }, |
| { { &set_windowProperty, NULL } }, |
| }, |
| { // Readonly attribute |
| "window", |
| JSPROP_SHARED | JSPROP_ENUMERATE, |
| { { &get_window, NULL } }, |
| JSNATIVE_WRAPPER(NULL), |
| }, |
| { // Read/Write property |
| "onEvent", |
| JSPROP_SHARED | JSPROP_ENUMERATE, |
| { { &get_onEvent, NULL } }, |
| { { &set_onEvent, NULL } }, |
| }, |
| JS_PS_END |
| }; |
| |
| const JSFunctionSpec prototype_functions[] = { |
| JS_FNSPEC( |
| "getStackTrace", fcn_getStackTrace, NULL, |
| 0, JSPROP_ENUMERATE, NULL), |
| JS_FNSPEC( |
| "setTimeout", fcn_setTimeout, NULL, |
| 1, JSPROP_ENUMERATE, NULL), |
| JS_FNSPEC( |
| "windowOperation", fcn_windowOperation, NULL, |
| 0, JSPROP_ENUMERATE, NULL), |
| JS_FS_END |
| }; |
| |
| const JSPropertySpec interface_object_properties[] = { |
| JS_PS_END |
| }; |
| |
| const JSFunctionSpec interface_object_functions[] = { |
| 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, MozjsGlobalInterfaceParent::GetPrototype(context, global_object)); |
| DCHECK(parent_prototype); |
| |
| interface_data->prototype = JS_NewObjectWithGivenProto( |
| context, &prototype_class_definition, parent_prototype |
| ); |
| |
| JS::RootedObject rooted_prototype(context, interface_data->prototype); |
| bool success = JS_DefineProperties( |
| context, |
| rooted_prototype, |
| prototype_properties); |
| |
| DCHECK(success); |
| success = JS_DefineFunctions( |
| context, rooted_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_object_class_definition, |
| function_prototype); |
| |
| // Add the InterfaceObject.name property. |
| JS::RootedObject rooted_interface_object( |
| context, interface_data->interface_object); |
| JS::RootedValue name_value(context); |
| const char name[] = |
| "Window"; |
| name_value.setString(JS_NewStringCopyZ(context, name)); |
| success = JS_DefineProperty( |
| context, rooted_interface_object, "name", name_value, JSPROP_READONLY, |
| NULL, NULL); |
| 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); |
| success = JS_LinkConstructorAndPrototype( |
| context, |
| rooted_interface_object, |
| rooted_prototype); |
| DCHECK(success); |
| } |
| |
| inline InterfaceData* GetInterfaceData(JSContext* context) { |
| const int kInterfaceUniqueId = 52; |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| // By convention, the |MozjsGlobalEnvironment| that we are associated with |
| // will hold our |InterfaceData| at index |kInterfaceUniqueId|, as we asked |
| // for it to be there in the first place, and could not have conflicted with |
| // any other interface. |
| return global_environment->GetInterfaceData(kInterfaceUniqueId); |
| } |
| |
| } // namespace |
| |
| JSObject* MozjsWindow::CreateProxy( |
| JSContext* context, const scoped_refptr<Wrappable>& wrappable) { |
| |
| InterfaceData* interface_data = GetInterfaceData(context); |
| |
| JS::RootedObject global_object( |
| context, JS_NewGlobalObject(context, |
| &instance_class_definition, NULL, |
| JS::FireOnNewGlobalHook, |
| JS::CompartmentOptions().setTrace(WrapperPrivate::Trace))); |
| DCHECK(global_object); |
| |
| // Initialize standard JS constructors prototypes and top-level functions such |
| // as Object, isNan, etc. |
| JSAutoCompartment auto_compartment(context, global_object); |
| bool success = JS_InitStandardClasses(context, global_object); |
| DCHECK(success); |
| |
| JS::RootedObject prototype( |
| context, MozjsWindow::GetPrototype(context, global_object)); |
| DCHECK(prototype); |
| JS_SetPrototype(context, global_object, prototype); |
| |
| JS_SetImmutablePrototype(context, global_object, &success); |
| DCHECK(success); |
| |
| // Add own properties. |
| success = JS_DefineProperties(context, global_object, own_properties); |
| DCHECK(success); |
| |
| JS::RootedObject proxy(context, |
| ProxyHandler::NewProxy( |
| context, proxy_handler.Pointer(), global_object, prototype)); |
| WrapperPrivate::AddPrivateData(context, proxy, wrappable); |
| |
| // Set the global object proxy pointer, so we can access the standard classes |
| // such as the base Object prototype when looking up our prototype. |
| MozjsGlobalEnvironment* global_environment = |
| static_cast<MozjsGlobalEnvironment*>(JS_GetContextPrivate(context)); |
| global_environment->SetGlobalObjectProxyAndWrapper(proxy, wrappable); |
| return proxy; |
| } |
| // static |
| const JSClass* MozjsWindow::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)); |
| const JSClass* proto_class = JS_GetClass(prototype); |
| return proto_class; |
| } |
| |
| // static |
| JSObject* MozjsWindow::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* MozjsWindow::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 |
| |
| namespace cobalt { |
| namespace script { |
| |
| template<> |
| void GlobalEnvironment::CreateGlobalObject<Window>( |
| const scoped_refptr<Window>& global_interface, |
| EnvironmentSettings* environment_settings) { |
| MozjsGlobalEnvironment* mozjs_global_environment = |
| base::polymorphic_downcast<MozjsGlobalEnvironment*>(this); |
| JSContext* context = mozjs_global_environment->context(); |
| |
| JSAutoRequest auto_request(context); |
| MozjsWindow::CreateProxy( |
| context, global_interface); |
| mozjs_global_environment->SetEnvironmentSettings(environment_settings); |
| mozjs_global_environment->EvaluateAutomatics(); |
| |
| WrapperFactory* wrapper_factory = |
| mozjs_global_environment->wrapper_factory(); |
| wrapper_factory->RegisterWrappableType( |
| AnonymousIndexedGetterInterface::AnonymousIndexedGetterInterfaceWrappableType(), |
| base::Bind(MozjsAnonymousIndexedGetterInterface::CreateProxy), |
| base::Bind(MozjsAnonymousIndexedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| AnonymousNamedGetterInterface::AnonymousNamedGetterInterfaceWrappableType(), |
| base::Bind(MozjsAnonymousNamedGetterInterface::CreateProxy), |
| base::Bind(MozjsAnonymousNamedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| AnonymousNamedIndexedGetterInterface::AnonymousNamedIndexedGetterInterfaceWrappableType(), |
| base::Bind(MozjsAnonymousNamedIndexedGetterInterface::CreateProxy), |
| base::Bind(MozjsAnonymousNamedIndexedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ArbitraryInterface::ArbitraryInterfaceWrappableType(), |
| base::Bind(MozjsArbitraryInterface::CreateProxy), |
| base::Bind(MozjsArbitraryInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| BaseInterface::BaseInterfaceWrappableType(), |
| base::Bind(MozjsBaseInterface::CreateProxy), |
| base::Bind(MozjsBaseInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| BooleanTypeTestInterface::BooleanTypeTestInterfaceWrappableType(), |
| base::Bind(MozjsBooleanTypeTestInterface::CreateProxy), |
| base::Bind(MozjsBooleanTypeTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| CallbackFunctionInterface::CallbackFunctionInterfaceWrappableType(), |
| base::Bind(MozjsCallbackFunctionInterface::CreateProxy), |
| base::Bind(MozjsCallbackFunctionInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| CallbackInterfaceInterface::CallbackInterfaceInterfaceWrappableType(), |
| base::Bind(MozjsCallbackInterfaceInterface::CreateProxy), |
| base::Bind(MozjsCallbackInterfaceInterface::PrototypeClass)); |
| #if defined(ENABLE_CONDITIONAL_INTERFACE) |
| wrapper_factory->RegisterWrappableType( |
| ConditionalInterface::ConditionalInterfaceWrappableType(), |
| base::Bind(MozjsConditionalInterface::CreateProxy), |
| base::Bind(MozjsConditionalInterface::PrototypeClass)); |
| #endif // defined(ENABLE_CONDITIONAL_INTERFACE) |
| wrapper_factory->RegisterWrappableType( |
| ConstantsInterface::ConstantsInterfaceWrappableType(), |
| base::Bind(MozjsConstantsInterface::CreateProxy), |
| base::Bind(MozjsConstantsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ConstructorInterface::ConstructorInterfaceWrappableType(), |
| base::Bind(MozjsConstructorInterface::CreateProxy), |
| base::Bind(MozjsConstructorInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ConstructorWithArgumentsInterface::ConstructorWithArgumentsInterfaceWrappableType(), |
| base::Bind(MozjsConstructorWithArgumentsInterface::CreateProxy), |
| base::Bind(MozjsConstructorWithArgumentsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| DOMStringTestInterface::DOMStringTestInterfaceWrappableType(), |
| base::Bind(MozjsDOMStringTestInterface::CreateProxy), |
| base::Bind(MozjsDOMStringTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| DerivedGetterSetterInterface::DerivedGetterSetterInterfaceWrappableType(), |
| base::Bind(MozjsDerivedGetterSetterInterface::CreateProxy), |
| base::Bind(MozjsDerivedGetterSetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| DerivedInterface::DerivedInterfaceWrappableType(), |
| base::Bind(MozjsDerivedInterface::CreateProxy), |
| base::Bind(MozjsDerivedInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| DictionaryInterface::DictionaryInterfaceWrappableType(), |
| base::Bind(MozjsDictionaryInterface::CreateProxy), |
| base::Bind(MozjsDictionaryInterface::PrototypeClass)); |
| #if defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| wrapper_factory->RegisterWrappableType( |
| DisabledInterface::DisabledInterfaceWrappableType(), |
| base::Bind(MozjsDisabledInterface::CreateProxy), |
| base::Bind(MozjsDisabledInterface::PrototypeClass)); |
| #endif // defined(NO_ENABLE_CONDITIONAL_INTERFACE) |
| wrapper_factory->RegisterWrappableType( |
| EnumerationInterface::EnumerationInterfaceWrappableType(), |
| base::Bind(MozjsEnumerationInterface::CreateProxy), |
| base::Bind(MozjsEnumerationInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ExceptionObjectInterface::ExceptionObjectInterfaceWrappableType(), |
| base::Bind(MozjsExceptionObjectInterface::CreateProxy), |
| base::Bind(MozjsExceptionObjectInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ExceptionsInterface::ExceptionsInterfaceWrappableType(), |
| base::Bind(MozjsExceptionsInterface::CreateProxy), |
| base::Bind(MozjsExceptionsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ExtendedIDLAttributesInterface::ExtendedIDLAttributesInterfaceWrappableType(), |
| base::Bind(MozjsExtendedIDLAttributesInterface::CreateProxy), |
| base::Bind(MozjsExtendedIDLAttributesInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| GarbageCollectionTestInterface::GarbageCollectionTestInterfaceWrappableType(), |
| base::Bind(MozjsGarbageCollectionTestInterface::CreateProxy), |
| base::Bind(MozjsGarbageCollectionTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| GlobalInterfaceParent::GlobalInterfaceParentWrappableType(), |
| base::Bind(MozjsGlobalInterfaceParent::CreateProxy), |
| base::Bind(MozjsGlobalInterfaceParent::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ImplementedInterface::ImplementedInterfaceWrappableType(), |
| base::Bind(MozjsImplementedInterface::CreateProxy), |
| base::Bind(MozjsImplementedInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| IndexedGetterInterface::IndexedGetterInterfaceWrappableType(), |
| base::Bind(MozjsIndexedGetterInterface::CreateProxy), |
| base::Bind(MozjsIndexedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| InterfaceWithAny::InterfaceWithAnyWrappableType(), |
| base::Bind(MozjsInterfaceWithAny::CreateProxy), |
| base::Bind(MozjsInterfaceWithAny::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| InterfaceWithAnyDictionary::InterfaceWithAnyDictionaryWrappableType(), |
| base::Bind(MozjsInterfaceWithAnyDictionary::CreateProxy), |
| base::Bind(MozjsInterfaceWithAnyDictionary::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| InterfaceWithUnsupportedProperties::InterfaceWithUnsupportedPropertiesWrappableType(), |
| base::Bind(MozjsInterfaceWithUnsupportedProperties::CreateProxy), |
| base::Bind(MozjsInterfaceWithUnsupportedProperties::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NamedConstructorInterface::NamedConstructorInterfaceWrappableType(), |
| base::Bind(MozjsNamedConstructorInterface::CreateProxy), |
| base::Bind(MozjsNamedConstructorInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NamedGetterInterface::NamedGetterInterfaceWrappableType(), |
| base::Bind(MozjsNamedGetterInterface::CreateProxy), |
| base::Bind(MozjsNamedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NamedIndexedGetterInterface::NamedIndexedGetterInterfaceWrappableType(), |
| base::Bind(MozjsNamedIndexedGetterInterface::CreateProxy), |
| base::Bind(MozjsNamedIndexedGetterInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NestedPutForwardsInterface::NestedPutForwardsInterfaceWrappableType(), |
| base::Bind(MozjsNestedPutForwardsInterface::CreateProxy), |
| base::Bind(MozjsNestedPutForwardsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NoConstructorInterface::NoConstructorInterfaceWrappableType(), |
| base::Bind(MozjsNoConstructorInterface::CreateProxy), |
| base::Bind(MozjsNoConstructorInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NoInterfaceObjectInterface::NoInterfaceObjectInterfaceWrappableType(), |
| base::Bind(MozjsNoInterfaceObjectInterface::CreateProxy), |
| base::Bind(MozjsNoInterfaceObjectInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NullableTypesTestInterface::NullableTypesTestInterfaceWrappableType(), |
| base::Bind(MozjsNullableTypesTestInterface::CreateProxy), |
| base::Bind(MozjsNullableTypesTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| NumericTypesTestInterface::NumericTypesTestInterfaceWrappableType(), |
| base::Bind(MozjsNumericTypesTestInterface::CreateProxy), |
| base::Bind(MozjsNumericTypesTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| ObjectTypeBindingsInterface::ObjectTypeBindingsInterfaceWrappableType(), |
| base::Bind(MozjsObjectTypeBindingsInterface::CreateProxy), |
| base::Bind(MozjsObjectTypeBindingsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| OperationsTestInterface::OperationsTestInterfaceWrappableType(), |
| base::Bind(MozjsOperationsTestInterface::CreateProxy), |
| base::Bind(MozjsOperationsTestInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| PromiseInterface::PromiseInterfaceWrappableType(), |
| base::Bind(MozjsPromiseInterface::CreateProxy), |
| base::Bind(MozjsPromiseInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| PutForwardsInterface::PutForwardsInterfaceWrappableType(), |
| base::Bind(MozjsPutForwardsInterface::CreateProxy), |
| base::Bind(MozjsPutForwardsInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| SequenceUser::SequenceUserWrappableType(), |
| base::Bind(MozjsSequenceUser::CreateProxy), |
| base::Bind(MozjsSequenceUser::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| StaticPropertiesInterface::StaticPropertiesInterfaceWrappableType(), |
| base::Bind(MozjsStaticPropertiesInterface::CreateProxy), |
| base::Bind(MozjsStaticPropertiesInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| StringifierAnonymousOperationInterface::StringifierAnonymousOperationInterfaceWrappableType(), |
| base::Bind(MozjsStringifierAnonymousOperationInterface::CreateProxy), |
| base::Bind(MozjsStringifierAnonymousOperationInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| StringifierAttributeInterface::StringifierAttributeInterfaceWrappableType(), |
| base::Bind(MozjsStringifierAttributeInterface::CreateProxy), |
| base::Bind(MozjsStringifierAttributeInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| StringifierOperationInterface::StringifierOperationInterfaceWrappableType(), |
| base::Bind(MozjsStringifierOperationInterface::CreateProxy), |
| base::Bind(MozjsStringifierOperationInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| TargetInterface::TargetInterfaceWrappableType(), |
| base::Bind(MozjsTargetInterface::CreateProxy), |
| base::Bind(MozjsTargetInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| UnionTypesInterface::UnionTypesInterfaceWrappableType(), |
| base::Bind(MozjsUnionTypesInterface::CreateProxy), |
| base::Bind(MozjsUnionTypesInterface::PrototypeClass)); |
| wrapper_factory->RegisterWrappableType( |
| Window::WindowWrappableType(), |
| base::Bind(DummyFunctor), |
| base::Bind(MozjsWindow::PrototypeClass)); |
| |
| } |
| |
| } // namespace script |
| } // namespace cobalt |
