From 2aa4a82499d4becd2284cdb482213d541b8804dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 16:29:10 +0200 Subject: Adding upstream version 86.0.1. Signed-off-by: Daniel Baumann --- dom/plugins/base/nsNPAPIPlugin.h | 288 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 288 insertions(+) create mode 100644 dom/plugins/base/nsNPAPIPlugin.h (limited to 'dom/plugins/base/nsNPAPIPlugin.h') diff --git a/dom/plugins/base/nsNPAPIPlugin.h b/dom/plugins/base/nsNPAPIPlugin.h new file mode 100644 index 0000000000..ebc0404932 --- /dev/null +++ b/dom/plugins/base/nsNPAPIPlugin.h @@ -0,0 +1,288 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsNPAPIPlugin_h_ +#define nsNPAPIPlugin_h_ + +#include "prlink.h" +#include "npfunctions.h" +#include "nsPluginHost.h" + +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/PluginLibrary.h" +#include "mozilla/RefCounted.h" + +// nsNPAPIPlugin is held alive both by active nsPluginTag instances and +// by active nsNPAPIPluginInstance. +class nsNPAPIPlugin final { + private: + typedef mozilla::PluginLibrary PluginLibrary; + + public: + nsNPAPIPlugin(); + + NS_INLINE_DECL_REFCOUNTING(nsNPAPIPlugin) + + // Constructs and initializes an nsNPAPIPlugin object. A nullptr file path + // will prevent this from calling NP_Initialize. + static nsresult CreatePlugin(nsPluginTag* aPluginTag, + nsNPAPIPlugin** aResult); + + PluginLibrary* GetLibrary(); + // PluginFuncs() can't fail but results are only valid if GetLibrary() + // succeeds + NPPluginFuncs* PluginFuncs(); + +#if defined(XP_MACOSX) && !defined(__LP64__) + void SetPluginRefNum(short aRefNum); +#endif + + // The IPC mechanism notifies the nsNPAPIPlugin if the plugin + // crashes and is no longer usable. pluginDumpID is the ID of the minidump + // that was written, or empty if no minidump was written. + void PluginCrashed(const nsAString& aPluginDumpID, + const nsACString& aAdditionalMinidumps); + + nsresult Shutdown(); + + static nsresult RetainStream(NPStream* pstream, nsISupports** aRetainedPeer); + + private: + ~nsNPAPIPlugin(); + + NPPluginFuncs mPluginFuncs; + PluginLibrary* mLibrary; +}; + +namespace mozilla { +namespace plugins { +namespace parent { + +static_assert(sizeof(NPIdentifier) == sizeof(jsid), + "NPIdentifier must be binary compatible with jsid."); + +inline jsid NPIdentifierToJSId(NPIdentifier id) { + jsid tmp; + JSID_BITS(tmp) = (size_t)id; + return tmp; +} + +inline NPIdentifier JSIdToNPIdentifier(jsid id) { + return (NPIdentifier)JSID_BITS(id); +} + +inline bool NPIdentifierIsString(NPIdentifier id) { + return JSID_IS_STRING(NPIdentifierToJSId(id)); +} + +inline JSString* NPIdentifierToString(NPIdentifier id) { + return JSID_TO_STRING(NPIdentifierToJSId(id)); +} + +inline NPIdentifier StringToNPIdentifier(JSContext* cx, JSString* str) { + return JSIdToNPIdentifier(JS::PropertyKey::fromPinnedString(str)); +} + +inline bool NPIdentifierIsInt(NPIdentifier id) { + return JSID_IS_INT(NPIdentifierToJSId(id)); +} + +inline int NPIdentifierToInt(NPIdentifier id) { + return JSID_TO_INT(NPIdentifierToJSId(id)); +} + +inline NPIdentifier IntToNPIdentifier(int i) { + return JSIdToNPIdentifier(INT_TO_JSID(i)); +} + +JSContext* GetJSContext(NPP npp); + +inline bool NPStringIdentifierIsPermanent(NPIdentifier id) { + AutoSafeJSContext cx; + return JS_StringHasBeenPinned(cx, NPIdentifierToString(id)); +} + +#define NPIdentifier_VOID (JSIdToNPIdentifier(JSID_VOID)) + +NPObject* _getwindowobject(NPP npp); + +NPObject* _getpluginelement(NPP npp); + +NPIdentifier _getstringidentifier(const NPUTF8* name); + +void _getstringidentifiers(const NPUTF8** names, int32_t nameCount, + NPIdentifier* identifiers); + +bool _identifierisstring(NPIdentifier identifiers); + +NPIdentifier _getintidentifier(int32_t intid); + +NPUTF8* _utf8fromidentifier(NPIdentifier identifier); + +int32_t _intfromidentifier(NPIdentifier identifier); + +NPObject* _createobject(NPP npp, NPClass* aClass); + +NPObject* _retainobject(NPObject* npobj); + +void _releaseobject(NPObject* npobj); + +bool _invoke(NPP npp, NPObject* npobj, NPIdentifier method, + const NPVariant* args, uint32_t argCount, NPVariant* result); + +bool _invokeDefault(NPP npp, NPObject* npobj, const NPVariant* args, + uint32_t argCount, NPVariant* result); + +bool _evaluate(NPP npp, NPObject* npobj, NPString* script, NPVariant* result); + +bool _getproperty(NPP npp, NPObject* npobj, NPIdentifier property, + NPVariant* result); + +bool _setproperty(NPP npp, NPObject* npobj, NPIdentifier property, + const NPVariant* value); + +bool _removeproperty(NPP npp, NPObject* npobj, NPIdentifier property); + +bool _hasproperty(NPP npp, NPObject* npobj, NPIdentifier propertyName); + +bool _hasmethod(NPP npp, NPObject* npobj, NPIdentifier methodName); + +bool _enumerate(NPP npp, NPObject* npobj, NPIdentifier** identifier, + uint32_t* count); + +bool _construct(NPP npp, NPObject* npobj, const NPVariant* args, + uint32_t argCount, NPVariant* result); + +void _releasevariantvalue(NPVariant* variant); + +void _setexception(NPObject* npobj, const NPUTF8* message); + +void _pushpopupsenabledstate(NPP npp, NPBool enabled); + +void _poppopupsenabledstate(NPP npp); + +NPError _getvalueforurl(NPP instance, NPNURLVariable variable, const char* url, + char** value, uint32_t* len); + +NPError _setvalueforurl(NPP instance, NPNURLVariable variable, const char* url, + const char* value, uint32_t len); + +typedef void (*PluginTimerFunc)(NPP npp, uint32_t timerID); + +uint32_t _scheduletimer(NPP instance, uint32_t interval, NPBool repeat, + PluginTimerFunc timerFunc); + +void _unscheduletimer(NPP instance, uint32_t timerID); + +NPError _popupcontextmenu(NPP instance, NPMenu* menu); + +NPBool _convertpoint(NPP instance, double sourceX, double sourceY, + NPCoordinateSpace sourceSpace, double* destX, + double* destY, NPCoordinateSpace destSpace); + +NPError _requestread(NPStream* pstream, NPByteRange* rangeList); + +NPError _geturlnotify(NPP npp, const char* relativeURL, const char* target, + void* notifyData); + +NPError _getvalue(NPP npp, NPNVariable variable, void* r_value); + +NPError _setvalue(NPP npp, NPPVariable variable, void* r_value); + +NPError _geturl(NPP npp, const char* relativeURL, const char* target); + +NPError _posturlnotify(NPP npp, const char* relativeURL, const char* target, + uint32_t len, const char* buf, NPBool file, + void* notifyData); + +NPError _posturl(NPP npp, const char* relativeURL, const char* target, + uint32_t len, const char* buf, NPBool file); + +void _status(NPP npp, const char* message); + +void _memfree(void* ptr); + +uint32_t _memflush(uint32_t size); + +void _reloadplugins(NPBool reloadPages); + +void _invalidaterect(NPP npp, NPRect* invalidRect); + +void _invalidateregion(NPP npp, NPRegion invalidRegion); + +void _forceredraw(NPP npp); + +const char* _useragent(NPP npp); + +void* _memalloc(uint32_t size); + +// Deprecated entry points for the old Java plugin. +void* /* OJI type: JRIEnv* */ +_getJavaEnv(); + +void* /* OJI type: jref */ +_getJavaPeer(NPP npp); + +void _urlredirectresponse(NPP instance, void* notifyData, NPBool allow); + +NPError _initasyncsurface(NPP instance, NPSize* size, NPImageFormat format, + void* initData, NPAsyncSurface* surface); + +NPError _finalizeasyncsurface(NPP instance, NPAsyncSurface* surface); + +void _setcurrentasyncsurface(NPP instance, NPAsyncSurface* surface, + NPRect* changed); + +} /* namespace parent */ +} /* namespace plugins */ +} /* namespace mozilla */ + +const char* PeekException(); + +void PopException(); + +class NPPStack { + public: + static NPP Peek() { return sCurrentNPP; } + + protected: + static NPP sCurrentNPP; +}; + +// XXXjst: The NPPAutoPusher stack is a bit redundant now that +// PluginDestructionGuard exists, and could thus be replaced by code +// that uses the PluginDestructionGuard list of plugins on the +// stack. But they're not identical, and to minimize code changes +// we're keeping both for the moment, and making NPPAutoPusher inherit +// the PluginDestructionGuard class to avoid having to keep two +// separate objects on the stack since we always want a +// PluginDestructionGuard where we use an NPPAutoPusher. + +class MOZ_STACK_CLASS NPPAutoPusher : public NPPStack, + protected PluginDestructionGuard { + public: + explicit NPPAutoPusher(NPP aNpp) + : PluginDestructionGuard(aNpp), mOldNPP(sCurrentNPP) { + NS_ASSERTION(aNpp, "Uh, null aNpp passed to NPPAutoPusher!"); + + sCurrentNPP = aNpp; + } + + ~NPPAutoPusher() { sCurrentNPP = mOldNPP; } + + private: + NPP mOldNPP; +}; + +class NPPExceptionAutoHolder { + public: + NPPExceptionAutoHolder(); + ~NPPExceptionAutoHolder(); + + protected: + char* mOldException; +}; + +#endif // nsNPAPIPlugin_h_ -- cgit v1.2.3