blob: b30eecbeeb7ac429b9cb48076bd238d3a8db429c [file] [log] [blame]
/*
* 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