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; }