JSValue* CInstance::invokeConstruct(ExecState* exec, const ArgList& args)
{
if (!_object->_class->construct)
return jsUndefined();
unsigned count = args.size();
Vector<NPVariant, 8> cArgs(count);
unsigned i;
for (i = 0; i < count; i++)
convertValueToNPVariant(exec, args.at(exec, i), &cArgs[i]);
// Invoke the 'C' method.
NPVariant resultVariant;
VOID_TO_NPVARIANT(resultVariant);
{
JSLock::DropAllLocks dropAllLocks(false);
_object->_class->construct(_object, cArgs.data(), count, &resultVariant);
}
for (i = 0; i < count; i++)
_NPN_ReleaseVariantValue(&cArgs[i]);
JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant, _rootObject.get());
_NPN_ReleaseVariantValue(&resultVariant);
return resultValue;
}
JSValue* CInstance::invokeMethod(ExecState* exec, const MethodList& methodList, const List& args)
{
// Overloading methods are not allowed by NPObjects. Should only be one
// name match for a particular method.
assert(methodList.length() == 1);
CMethod* method = static_cast<CMethod*>(methodList.methodAt(0));
NPIdentifier ident = _NPN_GetStringIdentifier(method->name());
if (!_object->_class->hasMethod(_object, ident))
return jsUndefined();
unsigned count = args.size();
Vector<NPVariant, 128> cArgs(count);
unsigned i;
for (i = 0; i < count; i++)
convertValueToNPVariant(exec, args.at(i), &cArgs[i]);
// Invoke the 'C' method.
NPVariant resultVariant;
VOID_TO_NPVARIANT(resultVariant);
_object->_class->invoke(_object, ident, cArgs, count, &resultVariant);
for (i = 0; i < count; i++)
_NPN_ReleaseVariantValue(&cArgs[i]);
JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant);
_NPN_ReleaseVariantValue(&resultVariant);
return resultValue;
}
EncodedJSValue JSC_HOST_CALL jsConsolePrototypeFunctionDebug(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue));
Console* imp = static_cast<Console*>(castedThis->impl());
unsigned count = exec->argumentCount();
Vector<NPVariant, 8> cArgs(count);
unsigned i;
for (i = 0; i < count; i++)
JSC::Bindings::convertValueToNPVariant(exec, exec->argument(i), &cArgs[i]);
// Invoke the 'C' method.
bool retval = true;
NPVariant resultVariant;
VOID_TO_NPVARIANT(resultVariant);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
//ASSERT(JSC::Bindings::globalExceptionString().isNull());
NPInvokeFunctionPtr ptr = (NPInvokeFunctionPtr)(imp->frame()->page()->chrome()->client()->getJavascriptCallCppCallback());
retval = ptr(0, 0, cArgs.data(), count, &resultVariant);
//CInstance::moveGlobalExceptionToExecState(exec);
}
if (!retval)
throwError(exec, createError(exec, "Error calling method on NPObject."));
for (i = 0; i < count; i++)
_NPN_ReleaseVariantValue(&cArgs[i]);
JSValue resultValue = JSC::Bindings::convertNPVariantToValue(exec, &resultVariant, 0);
_NPN_ReleaseVariantValue(&resultVariant);
return resultValue;
// JSValue thisValue = exec->hostThisValue();
// if (!thisValue.inherits(&JSConsole::s_info))
// return throwVMTypeError(exec);
// JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue));
// Console* imp = static_cast<Console*>(castedThis->impl());
// RefPtr<ScriptArguments> scriptArguments(createScriptArguments(exec, 0));
// size_t maxStackSize = imp->shouldCaptureFullStackTrace() ? ScriptCallStack::maxCallStackSizeToCapture : 1;
// RefPtr<ScriptCallStack> callStack(createScriptCallStack(exec, maxStackSize));
//
// imp->debug(scriptArguments, callStack);
// return JSValue::encode(jsUndefined());
}
JSValue* CField::valueFromInstance(ExecState* exec, const Instance* inst) const
{
const CInstance* instance = static_cast<const CInstance*>(inst);
NPObject* obj = instance->getObject();
if (obj->_class->getProperty) {
NPVariant property;
VOID_TO_NPVARIANT(property);
#ifdef ANDROID_NPN_SETEXCEPTION
SetGlobalException(0);
#endif // ANDROID_NPN_SETEXCEPTION
bool result;
{
JSLock::DropAllLocks dropAllLocks(false);
result = obj->_class->getProperty(obj, _fieldIdentifier, &property);
}
#ifdef ANDROID_NPN_SETEXCEPTION
MoveGlobalExceptionToExecState(exec);
#endif // ANDROID_NPN_SETEXCEPTION
if (result) {
JSValue* result = convertNPVariantToValue(exec, &property, instance->rootObject());
_NPN_ReleaseVariantValue(&property);
return result;
}
}
return jsUndefined();
}
static v8::Handle<v8::Value> npObjectGetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> key, v8::Isolate* isolate)
{
NPObject* npObject = v8ObjectToNPObject(self);
// Verify that our wrapper wasn't using a NPObject which
// has already been deleted.
if (!npObject || !_NPN_IsAlive(npObject))
return throwError(v8ReferenceError, "NPObject deleted", isolate);
if (npObject->_class->hasProperty && npObject->_class->getProperty && npObject->_class->hasProperty(npObject, identifier)) {
if (!_NPN_IsAlive(npObject))
return throwError(v8ReferenceError, "NPObject deleted", isolate);
NPVariant result;
VOID_TO_NPVARIANT(result);
if (!npObject->_class->getProperty(npObject, identifier, &result))
return v8Undefined();
v8::Handle<v8::Value> returnValue;
if (_NPN_IsAlive(npObject))
returnValue = convertNPVariantToV8Object(&result, npObject, isolate);
_NPN_ReleaseVariantValue(&result);
return returnValue;
}
if (!_NPN_IsAlive(npObject))
return throwError(v8ReferenceError, "NPObject deleted", isolate);
if (key->IsString() && npObject->_class->hasMethod && npObject->_class->hasMethod(npObject, identifier)) {
if (!_NPN_IsAlive(npObject))
return throwError(v8ReferenceError, "NPObject deleted", isolate);
PrivateIdentifier* id = static_cast<PrivateIdentifier*>(identifier);
UnsafePersistent<v8::FunctionTemplate> functionTemplate = V8NPTemplateMap::sharedInstance(isolate).get(id);
// FunctionTemplate caches function for each context.
v8::Local<v8::Function> v8Function;
// Cache templates using identifier as the key.
if (functionTemplate.isEmpty()) {
// Create a new template.
v8::Local<v8::FunctionTemplate> temp = v8::FunctionTemplate::New();
temp->SetCallHandler(npObjectMethodHandler, key);
V8NPTemplateMap::sharedInstance(isolate).set(id, temp);
v8Function = temp->GetFunction();
} else {
v8Function = functionTemplate.newLocal(isolate)->GetFunction();
}
v8Function->SetName(v8::Handle<v8::String>::Cast(key));
return v8Function;
}
return v8Undefined();
}
JSValue* CInstance::invokeDefaultMethod(ExecState* exec, const List& args)
{
if (!_object->_class->invokeDefault)
return jsUndefined();
unsigned count = args.size();
Vector<NPVariant, 128> cArgs(count);
unsigned i;
for (i = 0; i < count; i++)
convertValueToNPVariant(exec, args.at(i), &cArgs[i]);
// Invoke the 'C' method.
NPVariant resultVariant;
VOID_TO_NPVARIANT(resultVariant);
_object->_class->invokeDefault(_object, cArgs, count, &resultVariant);
for (i = 0; i < count; i++)
_NPN_ReleaseVariantValue(&cArgs[i]);
JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant);
_NPN_ReleaseVariantValue(&resultVariant);
return resultValue;
}
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue *aValue) const
{
const CInstance* instance = static_cast<const CInstance*>(inst);
NPObject* obj = instance->getObject();
if (obj->_class->setProperty) {
NPVariant variant;
convertValueToNPVariant(exec, aValue, &variant);
{
JSLock::DropAllLocks dropAllLocks;
obj->_class->setProperty(obj, _fieldIdentifier, &variant);
}
_NPN_ReleaseVariantValue(&variant);
}
}
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue aValue) const
{
const CInstance* instance = static_cast<const CInstance*>(inst);
NPObject* obj = instance->getObject();
if (obj->_class->setProperty) {
NPVariant variant;
convertValueToNPVariant(exec, aValue, &variant);
{
JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
obj->_class->setProperty(obj, _fieldIdentifier, &variant);
CInstance::moveGlobalExceptionToExecState(exec);
}
_NPN_ReleaseVariantValue(&variant);
}
}
JSValue* CField::valueFromInstance(ExecState* exec, const Instance* inst) const
{
const CInstance* instance = static_cast<const CInstance*>(inst);
NPObject* obj = instance->getObject();
if (obj->_class->getProperty) {
NPVariant property;
VOID_TO_NPVARIANT(property);
bool result;
{
JSLock::DropAllLocks dropAllLocks;
result = obj->_class->getProperty(obj, _fieldIdentifier, &property);
}
if (result) {
JSValue* result = convertNPVariantToValue(exec, &property, instance->rootObject());
_NPN_ReleaseVariantValue(&property);
return result;
}
}
return jsUndefined();
}
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue* aValue) const
{
const CInstance* instance = static_cast<const CInstance*>(inst);
NPObject* obj = instance->getObject();
if (obj->_class->setProperty) {
NPVariant variant;
convertValueToNPVariant(exec, aValue, &variant);
#ifdef ANDROID_NPN_SETEXCEPTION
SetGlobalException(0);
#endif // ANDROID_NPN_SETEXCEPTION
{
JSLock::DropAllLocks dropAllLocks(false);
obj->_class->setProperty(obj, _fieldIdentifier, &variant);
}
_NPN_ReleaseVariantValue(&variant);
#ifdef ANDROID_NPN_SETEXCEPTION
MoveGlobalExceptionToExecState(exec);
#endif // ANDROID_NPN_SETEXCEPTION
}
}
static v8::Handle<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> value, v8::Isolate* isolate)
{
NPObject* npObject = v8ObjectToNPObject(self);
// Verify that our wrapper wasn't using a NPObject which has already been deleted.
if (!npObject || !_NPN_IsAlive(npObject)) {
throwError(v8ReferenceError, "NPObject deleted", isolate);
return value; // Intercepted, but an exception was thrown.
}
if (npObject->_class->hasProperty && npObject->_class->setProperty && npObject->_class->hasProperty(npObject, identifier)) {
if (!_NPN_IsAlive(npObject))
return throwError(v8ReferenceError, "NPObject deleted", isolate);
NPVariant npValue;
VOID_TO_NPVARIANT(npValue);
convertV8ObjectToNPVariant(value, npObject, &npValue);
bool success = npObject->_class->setProperty(npObject, identifier, &npValue);
_NPN_ReleaseVariantValue(&npValue);
if (success)
return value; // Intercept the call.
}
return v8Undefined();
}
void WebBindings::releaseVariantValue(NPVariant* variant)
{
_NPN_ReleaseVariantValue(variant);
}
// FIXME: need comments.
// Params: holder could be HTMLEmbedElement or NPObject
static void npObjectInvokeImpl(const v8::FunctionCallbackInfo<v8::Value>& args, InvokeFunctionType functionId)
{
NPObject* npObject;
WrapperWorldType currentWorldType = worldType(args.GetIsolate());
// These three types are subtypes of HTMLPlugInElement.
if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType) || V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)
|| V8HTMLObjectElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)) {
// The holder object is a subtype of HTMLPlugInElement.
HTMLPlugInElement* element;
if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType))
element = V8HTMLAppletElement::toNative(args.Holder());
else if (V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType))
element = V8HTMLEmbedElement::toNative(args.Holder());
else
element = V8HTMLObjectElement::toNative(args.Holder());
ScriptInstance scriptInstance = element->getInstance();
if (scriptInstance) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
npObject = v8ObjectToNPObject(scriptInstance->newLocal(isolate));
} else
npObject = 0;
} else {
// The holder object is not a subtype of HTMLPlugInElement, it must be an NPObject which has three
// internal fields.
if (args.Holder()->InternalFieldCount() != npObjectInternalFieldCount) {
throwError(v8ReferenceError, "NPMethod called on non-NPObject", args.GetIsolate());
return;
}
npObject = v8ObjectToNPObject(args.Holder());
}
// Verify that our wrapper wasn't using a NPObject which has already been deleted.
if (!npObject || !_NPN_IsAlive(npObject)) {
throwError(v8ReferenceError, "NPObject deleted", args.GetIsolate());
return;
}
// Wrap up parameters.
int numArgs = args.Length();
OwnArrayPtr<NPVariant> npArgs = adoptArrayPtr(new NPVariant[numArgs]);
for (int i = 0; i < numArgs; i++)
convertV8ObjectToNPVariant(args[i], npObject, &npArgs[i]);
NPVariant result;
VOID_TO_NPVARIANT(result);
bool retval = true;
switch (functionId) {
case InvokeMethod:
if (npObject->_class->invoke) {
v8::Handle<v8::String> functionName = v8::Handle<v8::String>::Cast(args.Data());
NPIdentifier identifier = getStringIdentifier(functionName);
retval = npObject->_class->invoke(npObject, identifier, npArgs.get(), numArgs, &result);
}
break;
case InvokeConstruct:
if (npObject->_class->construct)
retval = npObject->_class->construct(npObject, npArgs.get(), numArgs, &result);
break;
case InvokeDefault:
if (npObject->_class->invokeDefault)
retval = npObject->_class->invokeDefault(npObject, npArgs.get(), numArgs, &result);
break;
default:
break;
}
if (!retval)
throwError(v8GeneralError, "Error calling method on NPObject.", args.GetIsolate());
for (int i = 0; i < numArgs; i++)
_NPN_ReleaseVariantValue(&npArgs[i]);
// Unwrap return values.
v8::Handle<v8::Value> returnValue;
if (_NPN_IsAlive(npObject))
returnValue = convertNPVariantToV8Object(&result, npObject, args.GetIsolate());
_NPN_ReleaseVariantValue(&result);
v8SetReturnValue(args, returnValue);
}
// KJS should only expose functions declared in npruntime.h (NPN_*)
// and npruntime_priv.h (which is an extension of npruntime.h), and
// not exposing _NPN_* functions declared in npruntime_impl.h.
// KJSBridge implements NPN_* functions by wrapping around _NPN_* functions.
//
// Following styles in JavaScriptCore/bindings/npruntime.cpp
void NPN_ReleaseVariantValue(NPVariant *variant) {
_NPN_ReleaseVariantValue(variant);
}
