bool NetscapePluginModule::tryGetSitesWithData(Vector<String>& sites) { if (!m_isInitialized) return false; // Check if the plug-in supports NPP_GetSitesWithData. if (!m_pluginFuncs.getsiteswithdata) return false; char** siteArray = m_pluginFuncs.getsiteswithdata(); // There were no sites with data. if (!siteArray) return true; for (int i = 0; siteArray[i]; ++i) { char* site = siteArray[i]; String siteString = String::fromUTF8(site); if (!siteString.isNull()) sites.append(siteString); npnMemFree(site); } npnMemFree(siteArray); return true; }
bool PluginPackage::tryGetSitesWithData(Vector<String>& sites) { if (!load()) return false; // FIXME: Find a better way to ensure the plugin is loaded. // PluginView::Init will load the plugin so decrement the counter m_loadCount--; // Check if the plug-in supports NPP_GetSitesWithData. if (!m_pluginFuncs.getsiteswithdata) return false; char** siteArray = m_pluginFuncs.getsiteswithdata(); // There were no sites with data. if (!siteArray) return true; for (int i = 0; siteArray[i]; ++i) { char* site = siteArray[i]; String siteString = String::fromUTF8(site); if (!siteString.isNull()) sites.append(siteString); npnMemFree(site); } npnMemFree(siteArray); return true; }
static NPError NPN_GetAuthenticationInfo(NPP npp, const char* protocol, const char* host, int32_t port, const char* scheme, const char* realm, char** username, uint32_t* usernameLength, char** password, uint32_t* passwordLength) { if (!protocol || !host || !scheme || !realm || !username || !usernameLength || !password || !passwordLength) return NPERR_GENERIC_ERROR; ProtectionSpace protectionSpace; if (!initializeProtectionSpace(protocol, host, port, scheme, realm, protectionSpace)) return NPERR_GENERIC_ERROR; RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp); String usernameString; String passwordString; if (!plugin->getAuthenticationInfo(protectionSpace, usernameString, passwordString)) return NPERR_GENERIC_ERROR; NPError result = copyCString(usernameString.utf8(), username, usernameLength); if (result != NPERR_NO_ERROR) return result; result = copyCString(passwordString.utf8(), password, passwordLength); if (result != NPERR_NO_ERROR) { npnMemFree(*username); return result; } return NPERR_NO_ERROR; }
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 deallocateNPObject(NPObject* npObject) { ASSERT(npObject); if (!npObject) return; if (npObject->_class->deallocate) npObject->_class->deallocate(npObject); else npnMemFree(npObject); }
bool NetscapePlugin::getFormValue(String& formValue) { ASSERT(m_isStarted); char* formValueString = 0; if (NPP_GetValue(NPPVformValue, &formValueString) != NPERR_NO_ERROR) return false; formValue = String::fromUTF8(formValueString); // The plug-in allocates the form value string with NPN_MemAlloc so it needs to be freed with NPN_MemFree. npnMemFree(formValueString); return true; }
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); }
void NPObjectMessageReceiver::enumerate(bool& returnValue, Vector<NPIdentifierData>& identifiersData) { if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(m_npObject->_class) || !m_npObject->_class->enumerate) { returnValue = false; return; } NPIdentifier* identifiers = 0; uint32_t identifierCount = 0; returnValue = m_npObject->_class->enumerate(m_npObject, &identifiers, &identifierCount); if (!returnValue) return; for (uint32_t i = 0; i < identifierCount; ++i) identifiersData.append(NPIdentifierData::fromNPIdentifier(identifiers[i])); npnMemFree(identifiers); }
static void NPN_MemFree(void* ptr) { npnMemFree(ptr); }