Source/WebKit2/WebProcess/Plugins/Netscape/JSNPObject.cpp - platform/external/webkit - Git at Google

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "JSNPObject.h"

 #include "JSNPMethod.h"
 #include "NPJSObject.h"
 #include "NPRuntimeObjectMap.h"
 #include "NPRuntimeUtilities.h"
 #include <JavaScriptCore/Error.h>
 #include <JavaScriptCore/JSGlobalObject.h>
 #include <JavaScriptCore/JSLock.h>
 #include <JavaScriptCore/ObjectPrototype.h>
 #include <WebCore/IdentifierRep.h>
 #include <wtf/text/WTFString.h>

 using namespace JSC;
 using namespace WebCore;

 namespace WebKit {

 static NPIdentifier npIdentifierFromIdentifier(const Identifier& identifier)
 {
     return static_cast<NPIdentifier>(IdentifierRep::get(identifier.ustring().utf8().data()));
 }

 const ClassInfo JSNPObject::s_info = { "NPObject", &JSObjectWithGlobalObject::s_info, 0, 0 };

 JSNPObject::JSNPObject(JSGlobalObject* globalObject, NPRuntimeObjectMap* objectMap, NPObject* npObject)
     : JSObjectWithGlobalObject(globalObject, createStructure(globalObject->globalData(), globalObject->objectPrototype()))
     , m_objectMap(objectMap)
     , m_npObject(npObject)
 {
     ASSERT(inherits(&s_info));

     // We should never have an NPJSObject inside a JSNPObject.
     ASSERT(!NPJSObject::isNPJSObject(m_npObject));

     retainNPObject(m_npObject);
 }

 JSNPObject::~JSNPObject()
 {
     if (!m_npObject)
         return;

     m_objectMap->jsNPObjectDestroyed(this);
     releaseNPObject(m_npObject);
 }

 void JSNPObject::invalidate()
 {
     ASSERT(m_npObject);

     releaseNPObject(m_npObject);
     m_npObject = 0;
 }

 JSValue JSNPObject::callMethod(ExecState* exec, NPIdentifier methodName)
 {
     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::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(SilenceAssertionsOnly);
         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)
         throwError(exec, createError(exec, "Error calling method on NPObject."));

     JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
     releaseNPVariantValue(&result);
     return propertyValue;
 }

 JSC::JSValue JSNPObject::callObject(JSC::ExecState* exec)
 {
     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::invokeDefault 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->invokeDefault(m_npObject, arguments.data(), argumentCount, &result);
         NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
     }

     // Release all arguments;
     for (size_t i = 0; i < argumentCount; ++i)
         releaseNPVariantValue(&arguments[i]);

     if (!returnValue)
         throwError(exec, createError(exec, "Error calling method on NPObject."));

     JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
     releaseNPVariantValue(&result);
     return propertyValue;
 }

 JSValue JSNPObject::callConstructor(ExecState* exec)
 {
     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;
 }

 static EncodedJSValue JSC_HOST_CALL callNPJSObject(ExecState* exec)
 {
     JSObject* object = exec->callee();
     ASSERT(object->inherits(&JSNPObject::s_info));

     return JSValue::encode(static_cast<JSNPObject*>(object)->callObject(exec));
 }

 JSC::CallType JSNPObject::getCallData(JSC::CallData& callData)
 {
     if (!m_npObject || !m_npObject->_class->invokeDefault)
         return CallTypeNone;

     callData.native.function = callNPJSObject;
     return CallTypeHost;
 }

 static EncodedJSValue JSC_HOST_CALL constructWithConstructor(ExecState* exec)
 {
     JSObject* constructor = exec->callee();
     ASSERT(constructor->inherits(&JSNPObject::s_info));

     return JSValue::encode(static_cast<JSNPObject*>(constructor)->callConstructor(exec));
 }

 ConstructType JSNPObject::getConstructData(ConstructData& constructData)
 {
     if (!m_npObject || !m_npObject->_class->construct)
         return ConstructTypeNone;

     constructData.native.function = constructWithConstructor;
     return ConstructTypeHost;
 }

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

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

 void JSNPObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot&)
 {
     if (!m_npObject) {
         throwInvalidAccessError(exec);
         return;
     }

     NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);

     if (!m_npObject->_class->hasProperty || !m_npObject->_class->hasProperty(m_npObject, npIdentifier)) {
         // FIXME: Should we throw an exception here?
         return;
     }

     if (!m_npObject->_class->setProperty)
         return;

     NPVariant variant;
     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(m_objectMap);

     {
         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
         m_npObject->_class->setProperty(m_npObject, npIdentifier, &variant);

         NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);

         // FIXME: Should we throw an exception if setProperty returns false?
     }

     releaseNPVariantValue(&variant);
 }

 void JSNPObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNameArray, EnumerationMode mode)
 {
     if (!m_npObject) {
         throwInvalidAccessError(exec);
         return;
     }

     if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(m_npObject->_class) || !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(m_objectMap);

     {
         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);

         // FIXME: Should we throw an exception if enumerate returns false?
         if (!m_npObject->_class->enumerate(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);
 }

 JSValue JSNPObject::propertyGetter(ExecState* exec, JSValue slotBase, const Identifier& propertyName)
 {
     JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase));

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

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

 JSObject* JSNPObject::throwInvalidAccessError(ExecState* exec)
 {
     return throwError(exec, createReferenceError(exec, "Trying to access object from destroyed plug-in."));
 }

 } // namespace WebKit
	/*
	* Copyright (C) 2010 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "JSNPObject.h"

	#include "JSNPMethod.h"
	#include "NPJSObject.h"
	#include "NPRuntimeObjectMap.h"
	#include "NPRuntimeUtilities.h"
	#include <JavaScriptCore/Error.h>
	#include <JavaScriptCore/JSGlobalObject.h>
	#include <JavaScriptCore/JSLock.h>
	#include <JavaScriptCore/ObjectPrototype.h>
	#include <WebCore/IdentifierRep.h>
	#include <wtf/text/WTFString.h>

	using namespace JSC;
	using namespace WebCore;

	namespace WebKit {

	static NPIdentifier npIdentifierFromIdentifier(const Identifier& identifier)
	{
	return static_cast<NPIdentifier>(IdentifierRep::get(identifier.ustring().utf8().data()));
	}

	const ClassInfo JSNPObject::s_info = { "NPObject", &JSObjectWithGlobalObject::s_info, 0, 0 };

	JSNPObject::JSNPObject(JSGlobalObject* globalObject, NPRuntimeObjectMap* objectMap, NPObject* npObject)
	: JSObjectWithGlobalObject(globalObject, createStructure(globalObject->globalData(), globalObject->objectPrototype()))
	, m_objectMap(objectMap)
	, m_npObject(npObject)
	{
	ASSERT(inherits(&s_info));

	// We should never have an NPJSObject inside a JSNPObject.
	ASSERT(!NPJSObject::isNPJSObject(m_npObject));

	retainNPObject(m_npObject);
	}

	JSNPObject::~JSNPObject()
	{
	if (!m_npObject)
	return;

	m_objectMap->jsNPObjectDestroyed(this);
	releaseNPObject(m_npObject);
	}

	void JSNPObject::invalidate()
	{
	ASSERT(m_npObject);

	releaseNPObject(m_npObject);
	m_npObject = 0;
	}

	JSValue JSNPObject::callMethod(ExecState* exec, NPIdentifier methodName)
	{
	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::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(SilenceAssertionsOnly);
	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)
	throwError(exec, createError(exec, "Error calling method on NPObject."));

	JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
	releaseNPVariantValue(&result);
	return propertyValue;
	}

	JSC::JSValue JSNPObject::callObject(JSC::ExecState* exec)
	{
	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::invokeDefault 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->invokeDefault(m_npObject, arguments.data(), argumentCount, &result);
	NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);
	}

	// Release all arguments;
	for (size_t i = 0; i < argumentCount; ++i)
	releaseNPVariantValue(&arguments[i]);

	if (!returnValue)
	throwError(exec, createError(exec, "Error calling method on NPObject."));

	JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(exec, globalObject(), result);
	releaseNPVariantValue(&result);
	return propertyValue;
	}

	JSValue JSNPObject::callConstructor(ExecState* exec)
	{
	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;
	}

	static EncodedJSValue JSC_HOST_CALL callNPJSObject(ExecState* exec)
	{
	JSObject* object = exec->callee();
	ASSERT(object->inherits(&JSNPObject::s_info));

	return JSValue::encode(static_cast<JSNPObject*>(object)->callObject(exec));
	}

	JSC::CallType JSNPObject::getCallData(JSC::CallData& callData)
	{
	if (!m_npObject \|\| !m_npObject->_class->invokeDefault)
	return CallTypeNone;

	callData.native.function = callNPJSObject;
	return CallTypeHost;
	}

	static EncodedJSValue JSC_HOST_CALL constructWithConstructor(ExecState* exec)
	{
	JSObject* constructor = exec->callee();
	ASSERT(constructor->inherits(&JSNPObject::s_info));

	return JSValue::encode(static_cast<JSNPObject*>(constructor)->callConstructor(exec));
	}

	ConstructType JSNPObject::getConstructData(ConstructData& constructData)
	{
	if (!m_npObject \|\| !m_npObject->_class->construct)
	return ConstructTypeNone;

	constructData.native.function = constructWithConstructor;
	return ConstructTypeHost;
	}

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

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

	void JSNPObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot&)
	{
	if (!m_npObject) {
	throwInvalidAccessError(exec);
	return;
	}

	NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);

	if (!m_npObject->_class->hasProperty \|\| !m_npObject->_class->hasProperty(m_npObject, npIdentifier)) {
	// FIXME: Should we throw an exception here?
	return;
	}

	if (!m_npObject->_class->setProperty)
	return;

	NPVariant variant;
	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(m_objectMap);

	{
	JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
	m_npObject->_class->setProperty(m_npObject, npIdentifier, &variant);

	NPRuntimeObjectMap::moveGlobalExceptionToExecState(exec);

	// FIXME: Should we throw an exception if setProperty returns false?
	}

	releaseNPVariantValue(&variant);
	}

	void JSNPObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNameArray, EnumerationMode mode)
	{
	if (!m_npObject) {
	throwInvalidAccessError(exec);
	return;
	}

	if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(m_npObject->_class) \|\| !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(m_objectMap);

	{
	JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);

	// FIXME: Should we throw an exception if enumerate returns false?
	if (!m_npObject->_class->enumerate(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);
	}

	JSValue JSNPObject::propertyGetter(ExecState* exec, JSValue slotBase, const Identifier& propertyName)
	{
	JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase));

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

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

	JSObject* JSNPObject::throwInvalidAccessError(ExecState* exec)
	{
	return throwError(exec, createReferenceError(exec, "Trying to access object from destroyed plug-in."));
	}

	} // namespace WebKit