PluginControllerProxy::~PluginControllerProxy()
{
ASSERT(!m_plugin);
if (m_windowNPObject)
releaseNPObject(m_windowNPObject);
if (m_pluginElementNPObject)
releaseNPObject(m_pluginElementNPObject);
}
void NPRuntimeObjectMap::invalidate()
{
Vector<NPJSObject*> npJSObjects;
copyValuesToVector(m_npJSObjects, npJSObjects);
// Deallocate all the object wrappers so we won't leak any JavaScript objects.
for (size_t i = 0; i < npJSObjects.size(); ++i)
deallocateNPObject(npJSObjects[i]);
// We shouldn't have any NPJSObjects left now.
ASSERT(m_npJSObjects.isEmpty());
Vector<NPObject*> objects;
for (HashMap<NPObject*, JSC::Weak<JSNPObject>>::iterator ptr = m_jsNPObjects.begin(), end = m_jsNPObjects.end(); ptr != end; ++ptr) {
JSNPObject* jsNPObject = ptr->value.get();
if (!jsNPObject) // Skip zombies.
continue;
objects.append(jsNPObject->leakNPObject());
}
m_jsNPObjects.clear();
for (size_t i = 0; i < objects.size(); ++i)
releaseNPObject(objects[i]);
// Deal with any objects that were scheduled for delayed destruction
if (m_npObjectsToFinalize.isEmpty())
return;
ASSERT(m_finalizationTimer.isActive());
m_finalizationTimer.stop();
invalidateQueuedObjects();
}
void JSNPObject::invalidate()
{
ASSERT(m_npObject);
releaseNPObject(m_npObject);
m_npObject = 0;
}
void releaseNPVariantValue(NPVariant* variant)
{
ASSERT(variant);
switch (variant->type) {
case NPVariantType_Void:
case NPVariantType_Null:
case NPVariantType_Bool:
case NPVariantType_Int32:
case NPVariantType_Double:
// Nothing to do.
break;
case NPVariantType_String:
npnMemFree(const_cast<NPUTF8*>(variant->value.stringValue.UTF8Characters));
variant->value.stringValue.UTF8Characters = 0;
variant->value.stringValue.UTF8Length = 0;
break;
case NPVariantType_Object:
releaseNPObject(variant->value.objectValue);
variant->value.objectValue = 0;
break;
}
variant->type = NPVariantType_Void;
}
void JSNPObject::invalidate()
{
ASSERT(m_npObject);
ASSERT_GC_OBJECT_INHERITS(this, &s_info);
releaseNPObject(m_npObject);
m_npObject = 0;
}
JSNPObject::~JSNPObject()
{
if (!m_npObject)
return;
m_objectMap->jsNPObjectDestroyed(this);
releaseNPObject(m_npObject);
}
void PluginControllerProxy::getPluginScriptableNPObject(uint64_t& pluginScriptableNPObjectID)
{
NPObject* pluginScriptableNPObject = m_plugin->pluginScriptableNPObject();
if (!pluginScriptableNPObject) {
pluginScriptableNPObjectID = 0;
return;
}
pluginScriptableNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(pluginScriptableNPObject, m_plugin.get());
releaseNPObject(pluginScriptableNPObject);
}
void PluginProxy::getPluginElementNPObject(uint64_t& pluginElementNPObjectID)
{
NPObject* pluginElementNPObject = controller()->pluginElementNPObject();
if (!pluginElementNPObject) {
pluginElementNPObjectID = 0;
return;
}
pluginElementNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(pluginElementNPObject, this);
releaseNPObject(pluginElementNPObject);
}
uint64_t PluginProxy::windowNPObjectID()
{
NPObject* windowScriptNPObject = controller()->windowScriptNPObject();
if (!windowScriptNPObject)
return 0;
uint64_t windowNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(windowScriptNPObject, this);
releaseNPObject(windowScriptNPObject);
return windowNPObjectID;
}
JSObject* PluginView::scriptObject(JSGlobalObject* globalObject)
{
// The plug-in can be null here if it failed to initialize.
if (!m_plugin)
return 0;
NPObject* scriptableNPObject = m_plugin->pluginScriptableNPObject();
if (!scriptableNPObject)
return 0;
JSObject* jsObject = m_npRuntimeObjectMap.getOrCreateJSObject(globalObject, scriptableNPObject);
releaseNPObject(scriptableNPObject);
return jsObject;
}
JSObject* PluginView::scriptObject(JSGlobalObject* globalObject)
{
// The plug-in can be null here if it failed to initialize.
if (!m_isInitialized || !m_plugin)
return 0;
#if ENABLE(NETSCAPE_PLUGIN_API)
NPObject* scriptableNPObject = m_plugin->pluginScriptableNPObject();
if (!scriptableNPObject)
return 0;
JSObject* jsObject = m_npRuntimeObjectMap.getOrCreateJSObject(globalObject, scriptableNPObject);
releaseNPObject(scriptableNPObject);
return jsObject;
#else
UNUSED_PARAM(globalObject);
return 0;
#endif
}
static void NPN_ReleaseObject(NPObject *npObject)
{
releaseNPObject(npObject);
}
NPObjectMessageReceiver::~NPObjectMessageReceiver()
{
m_npRemoteObjectMap->unregisterNPObject(m_npObjectID);
releaseNPObject(m_npObject);
}
