PassRefPtr<NodeFilter> toNodeFilter(JSValuePtr value)
{
if (value.isObject(&JSNodeFilter::s_info))
return static_cast<JSNodeFilter*>(asObject(value))->impl();
return NodeFilter::create(JSNodeFilterCondition::create(value));
}
void JSObjectSetPrototype(JSContextRef, JSObjectRef object, JSValueRef value)
{
JSObject* jsObject = toJS(object);
JSValuePtr jsValue = toJS(value);
jsObject->setPrototype(jsValue->isObject() ? jsValue : jsNull());
}
bool JSObject::hasInstance(ExecState* exec, JSValuePtr value, JSValuePtr proto)
{
if (!proto->isObject()) {
throwError(exec, TypeError, "instanceof called on an object with an invalid prototype property.");
return false;
}
if (!value->isObject())
return false;
JSObject* object = asObject(value);
while ((object = object->prototype()->getObject())) {
if (proto == object)
return true;
}
return false;
}
JSValuePtr booleanProtoFuncValueOf(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
{
if (thisValue.isBoolean())
return thisValue;
if (!thisValue.isObject(&BooleanObject::info))
return throwError(exec, TypeError);
return asBooleanObject(thisValue)->internalValue();
}
PassRefPtr<JSEventListener> JSDOMGlobalObject::findOrCreateJSEventListener(ExecState*, JSValuePtr val, bool isInline)
{
if (JSEventListener* listener = findJSEventListener(val, isInline))
return listener;
if (!val->isObject())
return 0;
// The JSEventListener constructor adds it to our jsEventListeners map.
return JSEventListener::create(asObject(val), this, isInline).get();
}
bool JSStorage::deleteProperty(ExecState* exec, const Identifier& propertyName)
{
// Only perform the custom delete if the object doesn't have a native property by this name.
// Since hasProperty() would end up calling canGetItemsForName() and be fooled, we need to check
// the native property slots manually.
PropertySlot slot;
if (getStaticValueSlot<JSStorage, Base>(exec, s_info.propHashTable(exec), this, propertyName, slot))
return false;
JSValuePtr prototype = this->prototype();
if (prototype->isObject() && asObject(prototype)->hasProperty(exec, propertyName))
return false;
m_impl->removeItem(propertyName);
return true;
}
NPObject* ScriptController::createScriptObjectForPluginElement(HTMLPlugInElement* plugin)
{
// Can't create NPObjects when JavaScript is disabled
if (!isEnabled())
return _NPN_CreateNoScriptObject();
// Create a JSObject bound to this element
JSLock lock(false);
ExecState* exec = globalObject()->globalExec();
JSValuePtr jsElementValue = toJS(exec, plugin);
if (!jsElementValue || !jsElementValue.isObject())
return _NPN_CreateNoScriptObject();
// Wrap the JSObject in an NPObject
return _NPN_CreateScriptObject(0, jsElementValue.getObject(), bindingRootObject());
}
JSValuePtr booleanProtoFuncToString(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
{
if (thisValue == jsBoolean(false))
return jsNontrivialString(exec, "false");
if (thisValue == jsBoolean(true))
return jsNontrivialString(exec, "true");
if (!thisValue.isObject(&BooleanObject::info))
return throwError(exec, TypeError);
if (asBooleanObject(thisValue)->internalValue() == jsBoolean(false))
return jsNontrivialString(exec, "false");
ASSERT(asBooleanObject(thisValue)->internalValue() == jsBoolean(true));
return jsNontrivialString(exec, "true");
}
static ALWAYS_INLINE JSValuePtr callDefaultValueFunction(ExecState* exec, const JSObject* object, const Identifier& propertyName)
{
JSValuePtr function = object->get(exec, propertyName);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return exec->exception();
// Prevent "toString" and "valueOf" from observing execution if an exception
// is pending.
if (exec->hadException())
return exec->exception();
JSValuePtr result = call(exec, function, callType, callData, const_cast<JSObject*>(object), exec->emptyList());
ASSERT(!result->isGetterSetter());
if (exec->hadException())
return exec->exception();
if (result->isObject())
return noValue();
return result;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValuePtr value, NPVariant* result)
{
JSLock lock(false);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8*)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(object);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
static PassRefPtr<PositionOptions> createPositionOptions(ExecState* exec, JSValuePtr value)
{
if (!value->isObject())
return 0;
JSObject* object = asObject(value);
JSValuePtr enableHighAccuracyValue = object->get(exec, Identifier(exec, "enableHighAccuracy"));
if (exec->hadException())
return 0;
bool enableHighAccuracy = enableHighAccuracyValue->toBoolean(exec);
if (exec->hadException())
return 0;
JSValuePtr timeoutValue = object->get(exec, Identifier(exec, "timeout"));
if (exec->hadException())
return 0;
unsigned timeout = timeoutValue->toUInt32(exec);
if (exec->hadException())
return 0;
return PositionOptions::create(enableHighAccuracy, timeout);
}
bool JSStorage::customPut(ExecState* exec, const Identifier& propertyName, JSValuePtr value, PutPropertySlot&)
{
// Only perform the custom put if the object doesn't have a native property by this name.
// Since hasProperty() would end up calling canGetItemsForName() and be fooled, we need to check
// the native property slots manually.
PropertySlot slot;
if (getStaticValueSlot<JSStorage, Base>(exec, s_info.propHashTable(exec), this, propertyName, slot))
return false;
JSValuePtr prototype = this->prototype();
if (prototype->isObject() && asObject(prototype)->hasProperty(exec, propertyName))
return false;
String stringValue = valueToStringWithNullCheck(exec, value);
if (exec->hadException())
return true;
ExceptionCode ec = 0;
impl()->setItem(propertyName, stringValue, ec);
setDOMException(exec, ec);
return true;
}
bool JSValueIsObject(JSContextRef, JSValueRef value)
{
JSValuePtr jsValue = toJS(value);
return jsValue.isObject();
}
bool JSDOMWindowBase::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
{
// Check for child frames by name before built-in properties to
// match Mozilla. This does not match IE, but some sites end up
// naming frames things that conflict with window properties that
// are in Moz but not IE. Since we have some of these, we have to do
// it the Moz way.
if (impl()->frame()->tree()->child(propertyName)) {
slot.setCustom(this, childFrameGetter);
return true;
}
const HashEntry* entry = JSDOMWindowBaseTable.entry(exec, propertyName);
if (entry) {
if (entry->attributes() & Function) {
if (entry->function() == windowProtoFuncShowModalDialog) {
if (!canShowModalDialog(impl()->frame()))
return false;
}
if (allowsAccessFrom(exec))
setUpStaticFunctionSlot(exec, entry, this, propertyName, slot);
else
slot.setUndefined();
} else
slot.setCustom(this, entry->propertyGetter());
return true;
}
// Do prototype lookup early so that functions and attributes in the prototype can have
// precedence over the index and name getters.
JSValuePtr proto = prototype();
if (proto->isObject()) {
if (asObject(proto)->getPropertySlot(exec, propertyName, slot)) {
if (!allowsAccessFrom(exec))
slot.setUndefined();
return true;
}
}
// FIXME: Search the whole frame hierachy somewhere around here.
// We need to test the correct priority order.
// allow window[1] or parent[1] etc. (#56983)
bool ok;
unsigned i = propertyName.toArrayIndex(&ok);
if (ok && i < impl()->frame()->tree()->childCount()) {
slot.setCustomIndex(this, i, indexGetter);
return true;
}
if (!allowsAccessFrom(exec)) {
slot.setUndefined();
return true;
}
// Allow shortcuts like 'Image1' instead of document.images.Image1
Document* document = impl()->frame()->document();
if (document && document->isHTMLDocument()) {
AtomicStringImpl* atomicPropertyName = AtomicString::find(propertyName);
if (atomicPropertyName && (static_cast<HTMLDocument*>(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
slot.setCustom(this, namedItemGetter);
return true;
}
}
return Base::getOwnPropertySlot(exec, propertyName, slot);
}
// ECMA 8.6.2.2
void JSObject::put(ExecState* exec, const Identifier& propertyName, JSValuePtr value, PutPropertySlot& slot)
{
ASSERT(value);
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
if (propertyName == exec->propertyNames().underscoreProto) {
// Setting __proto__ to a non-object, non-null value is silently ignored to match Mozilla.
if (!value->isObject() && !value->isNull())
return;
JSValuePtr nextPrototypeValue = value;
while (nextPrototypeValue && nextPrototypeValue->isObject()) {
JSObject* nextPrototype = asObject(nextPrototypeValue)->unwrappedObject();
if (nextPrototype == this) {
throwError(exec, GeneralError, "cyclic __proto__ value");
return;
}
nextPrototypeValue = nextPrototype->prototype();
}
setPrototype(value);
return;
}
// Check if there are any setters or getters in the prototype chain
JSValuePtr prototype;
for (JSObject* obj = this; !obj->structure()->hasGetterSetterProperties(); obj = asObject(prototype)) {
prototype = obj->prototype();
if (prototype->isNull()) {
putDirect(propertyName, value, 0, true, slot);
return;
}
}
unsigned attributes;
if ((m_structure->get(propertyName, attributes) != WTF::notFound) && attributes & ReadOnly)
return;
for (JSObject* obj = this; ; obj = asObject(prototype)) {
if (JSValuePtr gs = obj->getDirect(propertyName)) {
if (gs->isGetterSetter()) {
JSObject* setterFunc = asGetterSetter(gs)->setter();
if (!setterFunc) {
throwSetterError(exec);
return;
}
CallData callData;
CallType callType = setterFunc->getCallData(callData);
ArgList args;
args.append(value);
call(exec, setterFunc, callType, callData, this, args);
return;
}
// If there's an existing property on the object or one of its
// prototypes it should be replaced, so break here.
break;
}
prototype = obj->prototype();
if (prototype->isNull())
break;
}
putDirect(propertyName, value, 0, true, slot);
return;
}
jvalue convertValueToJValue(ExecState* exec, JSValuePtr value, JNIType _JNIType, const char* javaClassName)
{
JSLock lock(false);
jvalue result;
switch (_JNIType){
case array_type:
case object_type: {
result.l = (jobject)0;
// First see if we have a Java instance.
if (value->isObject()){
JSObject* objectImp = asObject(value);
if (objectImp->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(objectImp);
JavaInstance *instance = static_cast<JavaInstance*>(imp->getInternalInstance());
if (instance)
result.l = instance->javaInstance();
}
else if (objectImp->classInfo() == &RuntimeArray::s_info) {
// Input is a JavaScript Array that was originally created from a Java Array
RuntimeArray* imp = static_cast<RuntimeArray*>(objectImp);
JavaArray *array = static_cast<JavaArray*>(imp->getConcreteArray());
result.l = array->javaArray();
}
else if (objectImp->classInfo() == &JSArray::info) {
// Input is a Javascript Array. We need to create it to a Java Array.
result.l = convertArrayInstanceToJavaArray(exec, asArray(value), javaClassName);
}
}
// Now convert value to a string if the target type is a java.lang.string, and we're not
// converting from a Null.
if (result.l == 0 && strcmp(javaClassName, "java.lang.String") == 0) {
#ifdef CONVERT_NULL_TO_EMPTY_STRING
if (value->isNull()) {
JNIEnv *env = getJNIEnv();
jchar buf[2];
jobject javaString = env->functions->NewString (env, buf, 0);
result.l = javaString;
}
else
#else
if (!value->isNull())
#endif
{
UString stringValue = value->toString(exec);
JNIEnv *env = getJNIEnv();
jobject javaString = env->functions->NewString (env, (const jchar *)stringValue.data(), stringValue.size());
result.l = javaString;
}
} else if (result.l == 0)
bzero (&result, sizeof(jvalue)); // Handle it the same as a void case
}
break;
case boolean_type: {
result.z = (jboolean)value->toNumber(exec);
}
break;
case byte_type: {
result.b = (jbyte)value->toNumber(exec);
}
break;
case char_type: {
result.c = (jchar)value->toNumber(exec);
}
break;
case short_type: {
result.s = (jshort)value->toNumber(exec);
}
break;
case int_type: {
result.i = (jint)value->toNumber(exec);
}
break;
case long_type: {
result.j = (jlong)value->toNumber(exec);
}
break;
case float_type: {
result.f = (jfloat)value->toNumber(exec);
}
break;
case double_type: {
result.d = (jdouble)value->toNumber(exec);
}
break;
break;
case invalid_type:
default:
case void_type: {
bzero (&result, sizeof(jvalue));
}
break;
}
return result;
}