bool JSNPObject::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
if (!thisObject->m_npObject) {
throwInvalidAccessError(exec);
return false;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
// First, check if the NPObject has a property with this name.
if (thisObject->m_npObject->_class->hasProperty && thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
slot.setCustom(thisObject, thisObject->propertyGetter);
return true;
}
// Second, check if the NPObject has a method with this name.
if (thisObject->m_npObject->_class->hasMethod && thisObject->m_npObject->_class->hasMethod(thisObject->m_npObject, npIdentifier)) {
slot.setCustom(thisObject, thisObject->methodGetter);
return true;
}
return false;
}
JSValue JSNPObject::callConstructor(ExecState* exec)
{
ASSERT_GC_OBJECT_INHERITS(this, &s_info);
if (!m_npObject)
return throwInvalidAccessError(exec);
size_t argumentCount = exec->argumentCount();
Vector<NPVariant, 8> arguments(argumentCount);
// Convert all arguments to NPVariants.
for (size_t i = 0; i < argumentCount; ++i)
m_objectMap->convertJSValueToNPVariant(exec, exec->argument(i), arguments[i]);
// Calling NPClass::construct will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
bool returnValue;
NPVariant result;
VOID_TO_NPVARIANT(result);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
returnValue = m_npObject->_class->construct(m_npObject, arguments.data(), argumentCount, &result);
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
}
if (!returnValue)
throwError(exec, createError(exec, "Error calling method on NPObject."));
JSValue value = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
releaseNPVariantValue(&result);
return value;
}
bool JSNPObject::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
{
if (!m_npObject) {
throwInvalidAccessError(exec);
return false;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
// First, check if the NPObject has a property with this name.
if (m_npObject->_class->hasProperty && m_npObject->_class->hasProperty(m_npObject, npIdentifier)) {
PropertySlot slot;
slot.setCustom(this, propertyGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete);
return true;
}
// Second, check if the NPObject has a method with this name.
if (m_npObject->_class->hasMethod && m_npObject->_class->hasMethod(m_npObject, npIdentifier)) {
PropertySlot slot;
slot.setCustom(this, methodGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly);
return true;
}
return false;
}
bool JSNPObject::deleteProperty(ExecState* exec, NPIdentifier propertyName)
{
ASSERT_GC_OBJECT_INHERITS(this, &s_info);
if (!m_npObject) {
throwInvalidAccessError(exec);
return false;
}
if (!m_npObject->_class->removeProperty) {
// FIXME: Should we throw an exception here?
return false;
}
// Calling NPClass::setProperty will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
// FIXME: Should we throw an exception if removeProperty returns false?
if (!m_npObject->_class->removeProperty(m_npObject, propertyName))
return false;
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
}
return true;
}
bool JSNPObject::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
JSNPObject* thisObject = jsCast<JSNPObject*>(object);
ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
if (!thisObject->m_npObject) {
throwInvalidAccessError(exec);
return false;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
// First, check if the NPObject has a property with this name.
if (thisObject->m_npObject->_class->hasProperty && thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
PropertySlot slot;
slot.setCustom(thisObject, propertyGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete);
return true;
}
// Second, check if the NPObject has a method with this name.
if (thisObject->m_npObject->_class->hasMethod && thisObject->m_npObject->_class->hasMethod(thisObject->m_npObject, npIdentifier)) {
PropertySlot slot;
slot.setCustom(thisObject, methodGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly);
return true;
}
return false;
}
JSValue JSNPObject::propertyGetter(ExecState* exec, JSValue slotBase, PropertyName propertyName)
{
JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase));
ASSERT_GC_OBJECT_INHERITS(thisObj, &s_info);
if (!thisObj->m_npObject)
return throwInvalidAccessError(exec);
if (!thisObj->m_npObject->_class->getProperty)
return jsUndefined();
NPVariant result;
VOID_TO_NPVARIANT(result);
// Calling NPClass::getProperty will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(thisObj->m_objectMap);
bool returnValue;
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
returnValue = thisObj->m_npObject->_class->getProperty(thisObj->m_npObject, npIdentifier, &result);
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
}
if (!returnValue)
return jsUndefined();
JSValue propertyValue = thisObj->m_objectMap->convertNPVariantToJSValue(exec, thisObj->globalObject(), result);
releaseNPVariantValue(&result);
return propertyValue;
}
bool JSNPObject::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(object);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
if (!thisObject->m_npObject) {
throwInvalidAccessError(exec);
return false;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
// Calling NPClass::invoke will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
// First, check if the NPObject has a property with this name.
if (thisObject->m_npObject->_class->hasProperty && thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
slot.setCustom(thisObject, DontDelete, thisObject->propertyGetter);
return true;
}
// Second, check if the NPObject has a method with this name.
if (thisObject->m_npObject->_class->hasMethod && thisObject->m_npObject->_class->hasMethod(thisObject->m_npObject, npIdentifier)) {
slot.setCustom(thisObject, DontDelete | ReadOnly, thisObject->methodGetter);
return true;
}
return false;
}
JSValue JSNPObject::methodGetter(ExecState* exec, JSValue slotBase, const Identifier& methodName)
{
JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase));
if (!thisObj->m_npObject)
return throwInvalidAccessError(exec);
NPIdentifier npIdentifier = npIdentifierFromIdentifier(methodName);
return new (exec) JSNPMethod(exec, thisObj->globalObject(), methodName, npIdentifier);
}
EncodedJSValue JSNPObject::methodGetter(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue, PropertyName propertyName)
{
JSNPObject* thisObj = jsCast<JSNPObject*>(JSValue::decode(slotBase));
ASSERT_GC_OBJECT_INHERITS(thisObj, info());
if (!thisObj->m_npObject)
return JSValue::encode(throwInvalidAccessError(exec));
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
return JSValue::encode(JSNPMethod::create(exec, thisObj->globalObject(), propertyName.publicName(), npIdentifier));
}
JSValue JSNPObject::methodGetter(ExecState* exec, JSValue slotBase, PropertyName methodName)
{
JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase));
ASSERT_GC_OBJECT_INHERITS(thisObj, &s_info);
if (!thisObj->m_npObject)
return throwInvalidAccessError(exec);
NPIdentifier npIdentifier = npIdentifierFromIdentifier(methodName);
return JSNPMethod::create(exec, thisObj->globalObject(), methodName.ustring(), npIdentifier);
}
JSValue RuntimeObject::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const
{
if (!m_instance)
return throwInvalidAccessError(exec);
RefPtr<Instance> instance = m_instance;
instance->begin();
JSValue result = instance->defaultValue(exec, hint);
instance->end();
return result;
}
void RuntimeObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode)
{
if (!m_instance) {
throwInvalidAccessError(exec);
return;
}
RefPtr<Instance> instance = m_instance;
instance->begin();
instance->getPropertyNames(exec, propertyNames);
instance->end();
}
JSValue RuntimeObject::defaultValue(const JSObject* object, ExecState* exec, PreferredPrimitiveType hint)
{
const RuntimeObject* thisObject = jsCast<const RuntimeObject*>(object);
if (!thisObject->m_instance)
return throwInvalidAccessError(exec);
RefPtr<Instance> instance = thisObject->m_instance;
instance->begin();
JSValue result = instance->defaultValue(exec, hint);
instance->end();
return result;
}
void RuntimeObject::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode)
{
RuntimeObject* thisObject = jsCast<RuntimeObject*>(object);
if (!thisObject->m_instance) {
throwInvalidAccessError(exec);
return;
}
RefPtr<Instance> instance = thisObject->m_instance;
instance->begin();
instance->getPropertyNames(exec, propertyNames);
instance->end();
}
bool RuntimeObject::getOwnPropertyDescriptor(JSObject* object, ExecState *exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
RuntimeObject* thisObject = jsCast<RuntimeObject*>(object);
if (!thisObject->m_instance) {
throwInvalidAccessError(exec);
return false;
}
RefPtr<Instance> instance = thisObject->m_instance;
instance->begin();
Class *aClass = instance->getClass();
if (aClass) {
// See if the instance has a field with the specified name.
Field *aField = aClass->fieldNamed(propertyName, instance.get());
if (aField) {
PropertySlot slot;
slot.setCustom(thisObject, fieldGetter);
instance->end();
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete);
return true;
} else {
// Now check if a method with specified name exists, if so return a function object for
// that method.
MethodList methodList = aClass->methodsNamed(propertyName, instance.get());
if (methodList.size() > 0) {
PropertySlot slot;
slot.setCustom(thisObject, methodGetter);
instance->end();
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly);
return true;
}
}
// Try a fallback object.
if (!aClass->fallbackObject(exec, instance.get(), propertyName).isUndefined()) {
PropertySlot slot;
slot.setCustom(thisObject, fallbackObjectGetter);
instance->end();
descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly | DontEnum);
return true;
}
}
instance->end();
return instance->getOwnPropertyDescriptor(thisObject, exec, propertyName, descriptor);
}
EncodedJSValue RuntimeObject::methodGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName, JSObject*)
{
RuntimeObject* thisObj = jsCast<RuntimeObject*>(JSValue::decode(thisValue));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return JSValue::encode(throwInvalidAccessError(exec));
instance->begin();
JSValue method = instance->getMethod(exec, propertyName);
instance->end();
return JSValue::encode(method);
}
JSValue RuntimeObject::methodGetter(ExecState* exec, JSValue slotBase, PropertyName propertyName)
{
RuntimeObject* thisObj = static_cast<RuntimeObject*>(asObject(slotBase));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return throwInvalidAccessError(exec);
instance->begin();
JSValue method = instance->getMethod(exec, propertyName);
instance->end();
return method;
}
void JSNPObject::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNameArray, EnumerationMode mode)
{
JSNPObject* thisObject = jsCast<JSNPObject*>(object);
ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
if (!thisObject->m_npObject) {
throwInvalidAccessError(exec);
return;
}
if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(thisObject->m_npObject->_class) || !thisObject->m_npObject->_class->enumerate)
return;
NPIdentifier* identifiers = 0;
uint32_t identifierCount = 0;
// Calling NPClass::enumerate will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
// FIXME: Should we throw an exception if enumerate returns false?
if (!thisObject->m_npObject->_class->enumerate(thisObject->m_npObject, &identifiers, &identifierCount))
return;
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
}
for (uint32_t i = 0; i < identifierCount; ++i) {
IdentifierRep* identifierRep = static_cast<IdentifierRep*>(identifiers[i]);
Identifier identifier;
if (identifierRep->isString()) {
const char* string = identifierRep->string();
int length = strlen(string);
identifier = Identifier(exec, String::fromUTF8WithLatin1Fallback(string, length).impl());
} else
identifier = Identifier::from(exec, identifierRep->number());
propertyNameArray.add(identifier);
}
npnMemFree(identifiers);
}
EncodedJSValue RuntimeObject::fallbackObjectGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName, JSObject*)
{
RuntimeObject* thisObj = jsCast<RuntimeObject*>(JSValue::decode(thisValue));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return JSValue::encode(throwInvalidAccessError(exec));
instance->begin();
Class *aClass = instance->getClass();
JSValue result = aClass->fallbackObject(exec, instance.get(), propertyName);
instance->end();
return JSValue::encode(result);
}
JSValue RuntimeObject::fallbackObjectGetter(ExecState* exec, JSValue slotBase, PropertyName propertyName)
{
RuntimeObject* thisObj = static_cast<RuntimeObject*>(asObject(slotBase));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return throwInvalidAccessError(exec);
instance->begin();
Class *aClass = instance->getClass();
JSValue result = aClass->fallbackObject(exec, instance.get(), propertyName);
instance->end();
return result;
}
bool RuntimeObject::getOwnPropertySlot(JSCell* cell, ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
{
RuntimeObject* thisObject = static_cast<RuntimeObject*>(cell);
if (!thisObject->m_instance) {
throwInvalidAccessError(exec);
return false;
}
RefPtr<Instance> instance = thisObject->m_instance;
instance->begin();
Class *aClass = instance->getClass();
if (aClass) {
// See if the instance has a field with the specified name.
Field *aField = aClass->fieldNamed(propertyName, instance.get());
if (aField) {
slot.setCustom(thisObject, thisObject->fieldGetter);
instance->end();
return true;
} else {
// Now check if a method with specified name exists, if so return a function object for
// that method.
MethodList methodList = aClass->methodsNamed(propertyName, instance.get());
if (methodList.size() > 0) {
slot.setCustom(thisObject, thisObject->methodGetter);
instance->end();
return true;
}
}
// Try a fallback object.
if (!aClass->fallbackObject(exec, instance.get(), propertyName).isUndefined()) {
slot.setCustom(thisObject, thisObject->fallbackObjectGetter);
instance->end();
return true;
}
}
instance->end();
return instance->getOwnPropertySlot(thisObject, exec, propertyName, slot);
}
EncodedJSValue RuntimeObject::fieldGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName)
{
RuntimeObject* thisObj = jsCast<RuntimeObject*>(JSValue::decode(thisValue));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return JSValue::encode(throwInvalidAccessError(exec));
instance->begin();
Class *aClass = instance->getClass();
Field* aField = aClass->fieldNamed(propertyName, instance.get());
JSValue result = aField->valueFromInstance(exec, instance.get());
instance->end();
return JSValue::encode(result);
}
JSValue RuntimeObject::fieldGetter(ExecState* exec, JSValue slotBase, const Identifier& propertyName)
{
RuntimeObject* thisObj = static_cast<RuntimeObject*>(asObject(slotBase));
RefPtr<Instance> instance = thisObj->m_instance;
if (!instance)
return throwInvalidAccessError(exec);
instance->begin();
Class *aClass = instance->getClass();
Field* aField = aClass->fieldNamed(propertyName, instance.get());
JSValue result = aField->valueFromInstance(exec, instance.get());
instance->end();
return result;
}
void RuntimeObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
{
if (!m_instance) {
throwInvalidAccessError(exec);
return;
}
RefPtr<Instance> instance = m_instance;
instance->begin();
// Set the value of the property.
Field *aField = instance->getClass()->fieldNamed(propertyName, instance.get());
if (aField)
aField->setValueToInstance(exec, instance.get(), value);
else if (!instance->setValueOfUndefinedField(exec, propertyName, value))
instance->put(this, exec, propertyName, value, slot);
instance->end();
}
void RuntimeObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
RuntimeObject* thisObject = jsCast<RuntimeObject*>(cell);
if (!thisObject->m_instance) {
throwInvalidAccessError(exec);
return;
}
RefPtr<Instance> instance = thisObject->m_instance;
instance->begin();
// Set the value of the property.
Field *aField = instance->getClass()->fieldNamed(propertyName, instance.get());
if (aField)
aField->setValueToInstance(exec, instance.get(), value);
else if (!instance->setValueOfUndefinedField(exec, propertyName, value))
instance->put(thisObject, exec, propertyName, value, slot);
instance->end();
}
JSValue JSNPObject::callMethod(ExecState* exec, NPIdentifier methodName)
{
ASSERT_GC_OBJECT_INHERITS(this, info());
if (!m_npObject)
return throwInvalidAccessError(exec);
size_t argumentCount = exec->argumentCount();
Vector<NPVariant, 8> arguments(argumentCount);
// Convert all arguments to NPVariants.
for (size_t i = 0; i < argumentCount; ++i)
m_objectMap->convertJSValueToNPVariant(exec, exec->uncheckedArgument(i), arguments[i]);
// Calling NPClass::invoke will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
bool returnValue;
NPVariant result;
VOID_TO_NPVARIANT(result);
{
JSLock::DropAllLocks dropAllLocks(JSDOMWindowBase::commonVM());
returnValue = m_npObject->_class->invoke(m_npObject, methodName, arguments.data(), argumentCount, &result);
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
}
// Release all arguments;
for (size_t i = 0; i < argumentCount; ++i)
releaseNPVariantValue(&arguments[i]);
if (!returnValue)
exec->vm().throwException(exec, createError(exec, "Error calling method on NPObject."));
JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
releaseNPVariantValue(&result);
return propertyValue;
}
void JSNPObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot&)
{
JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
if (!thisObject->m_npObject) {
throwInvalidAccessError(exec);
return;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
if (!thisObject->m_npObject->_class->hasProperty || !thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
// FIXME: Should we throw an exception here?
return;
}
if (!thisObject->m_npObject->_class->setProperty)
return;
NPVariant variant;
thisObject->m_objectMap->convertJSValueToNPVariant(exec, value, variant);
// Calling NPClass::setProperty will call into plug-in code, and there's no telling what the plug-in can do.
// (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
// the call has finished.
NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
thisObject->m_npObject->_class->setProperty(thisObject->m_npObject, npIdentifier, &variant);
NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
// FIXME: Should we throw an exception if setProperty returns false?
}
releaseNPVariantValue(&variant);
}
bool JSNPObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
{
if (!m_npObject) {
throwInvalidAccessError(exec);
return false;
}
NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
// First, check if the NPObject has a property with this name.
if (m_npObject->_class->hasProperty && m_npObject->_class->hasProperty(m_npObject, npIdentifier)) {
slot.setCustom(this, propertyGetter);
return true;
}
// Second, check if the NPObject has a method with this name.
if (m_npObject->_class->hasMethod && m_npObject->_class->hasMethod(m_npObject, npIdentifier)) {
slot.setCustom(this, methodGetter);
return true;
}
return false;
}
