summaryrefslogtreecommitdiffstats
path: root/dom/plugins/base/nsNPAPIPluginInstance.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/plugins/base/nsNPAPIPluginInstance.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/plugins/base/nsNPAPIPluginInstance.h')
-rw-r--r--dom/plugins/base/nsNPAPIPluginInstance.h464
1 files changed, 464 insertions, 0 deletions
diff --git a/dom/plugins/base/nsNPAPIPluginInstance.h b/dom/plugins/base/nsNPAPIPluginInstance.h
new file mode 100644
index 000000000..5f0375637
--- /dev/null
+++ b/dom/plugins/base/nsNPAPIPluginInstance.h
@@ -0,0 +1,464 @@
+/* -*- Mode: C++; tab-width: 4; 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 nsNPAPIPluginInstance_h_
+#define nsNPAPIPluginInstance_h_
+
+#include "nsSize.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "nsPIDOMWindow.h"
+#include "nsITimer.h"
+#include "nsIPluginInstanceOwner.h"
+#include "nsIURI.h"
+#include "nsIChannel.h"
+#include "nsHashKeys.h"
+#include <prinrval.h>
+#include "js/TypeDecls.h"
+#include "nsIAudioChannelAgent.h"
+#ifdef MOZ_WIDGET_ANDROID
+#include "nsIRunnable.h"
+#include "GLContextTypes.h"
+#include "AndroidSurfaceTexture.h"
+#include "AndroidBridge.h"
+#include <map>
+class PluginEventRunnable;
+#endif
+
+#include "mozilla/EventForwards.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/PluginLibrary.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/WeakPtr.h"
+
+class nsPluginStreamListenerPeer; // browser-initiated stream class
+class nsNPAPIPluginStreamListener; // plugin-initiated stream class
+class nsIPluginInstanceOwner;
+class nsIOutputStream;
+class nsPluginInstanceOwner;
+
+#if defined(OS_WIN)
+const NPDrawingModel kDefaultDrawingModel = NPDrawingModelSyncWin;
+#elif defined(MOZ_X11)
+const NPDrawingModel kDefaultDrawingModel = NPDrawingModelSyncX;
+#elif defined(XP_MACOSX)
+#ifndef NP_NO_QUICKDRAW
+const NPDrawingModel kDefaultDrawingModel = NPDrawingModelQuickDraw; // Not supported
+#else
+const NPDrawingModel kDefaultDrawingModel = NPDrawingModelCoreGraphics;
+#endif
+#else
+const NPDrawingModel kDefaultDrawingModel = static_cast<NPDrawingModel>(0);
+#endif
+
+/**
+ * Used to indicate whether it's OK to reenter Gecko and repaint, flush frames,
+ * run scripts, etc, during this plugin call.
+ * When NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO is set, we try to avoid dangerous
+ * Gecko activities when the plugin spins a nested event loop, on a best-effort
+ * basis.
+ */
+enum NSPluginCallReentry {
+ NS_PLUGIN_CALL_SAFE_TO_REENTER_GECKO,
+ NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO
+};
+
+class nsNPAPITimer
+{
+public:
+ NPP npp;
+ uint32_t id;
+ nsCOMPtr<nsITimer> timer;
+ void (*callback)(NPP npp, uint32_t timerID);
+ bool inCallback;
+ bool needUnschedule;
+};
+
+class nsNPAPIPluginInstance final : public nsIAudioChannelAgentCallback
+ , public mozilla::SupportsWeakPtr<nsNPAPIPluginInstance>
+{
+private:
+ typedef mozilla::PluginLibrary PluginLibrary;
+
+public:
+ typedef mozilla::gfx::DrawTarget DrawTarget;
+
+ MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsNPAPIPluginInstance)
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIAUDIOCHANNELAGENTCALLBACK
+
+ nsresult Initialize(nsNPAPIPlugin *aPlugin, nsPluginInstanceOwner* aOwner, const nsACString& aMIMEType);
+ nsresult Start();
+ nsresult Stop();
+ nsresult SetWindow(NPWindow* window);
+ nsresult NewStreamFromPlugin(const char* type, const char* target, nsIOutputStream* *result);
+ nsresult Print(NPPrint* platformPrint);
+ nsresult HandleEvent(void* event, int16_t* result,
+ NSPluginCallReentry aSafeToReenterGecko = NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
+ nsresult GetValueFromPlugin(NPPVariable variable, void* value);
+ nsresult GetDrawingModel(int32_t* aModel);
+ nsresult IsRemoteDrawingCoreAnimation(bool* aDrawing);
+ nsresult ContentsScaleFactorChanged(double aContentsScaleFactor);
+ nsresult CSSZoomFactorChanged(float aCSSZoomFactor);
+ nsresult GetJSObject(JSContext *cx, JSObject** outObject);
+ bool ShouldCache();
+ nsresult IsWindowless(bool* isWindowless);
+ nsresult AsyncSetWindow(NPWindow* window);
+ nsresult GetImageContainer(mozilla::layers::ImageContainer **aContainer);
+ nsresult GetImageSize(nsIntSize* aSize);
+ nsresult NotifyPainted(void);
+ nsresult GetIsOOP(bool* aIsOOP);
+ nsresult SetBackgroundUnknown();
+ nsresult BeginUpdateBackground(nsIntRect* aRect, DrawTarget** aContext);
+ nsresult EndUpdateBackground(nsIntRect* aRect);
+ nsresult IsTransparent(bool* isTransparent);
+ nsresult GetFormValue(nsAString& aValue);
+ nsresult PushPopupsEnabledState(bool aEnabled);
+ nsresult PopPopupsEnabledState();
+ nsresult GetPluginAPIVersion(uint16_t* version);
+ nsresult InvalidateRect(NPRect *invalidRect);
+ nsresult InvalidateRegion(NPRegion invalidRegion);
+ nsresult GetMIMEType(const char* *result);
+#if defined(XP_WIN)
+ nsresult GetScrollCaptureContainer(mozilla::layers::ImageContainer **aContainer);
+#endif
+ nsresult HandledWindowedPluginKeyEvent(
+ const mozilla::NativeEventData& aKeyEventData,
+ bool aIsConsumed);
+ nsPluginInstanceOwner* GetOwner();
+ void SetOwner(nsPluginInstanceOwner *aOwner);
+ void DidComposite();
+
+ bool HasAudioChannelAgent() const
+ {
+ return !!mAudioChannelAgent;
+ }
+
+ nsresult GetOrCreateAudioChannelAgent(nsIAudioChannelAgent** aAgent);
+
+ nsresult SetMuted(bool aIsMuted);
+
+ nsNPAPIPlugin* GetPlugin();
+
+ nsresult GetNPP(NPP * aNPP);
+
+ NPError SetWindowless(bool aWindowless);
+
+ NPError SetTransparent(bool aTransparent);
+
+ NPError SetWantsAllNetworkStreams(bool aWantsAllNetworkStreams);
+
+ NPError SetUsesDOMForCursor(bool aUsesDOMForCursor);
+ bool UsesDOMForCursor();
+
+ void SetDrawingModel(NPDrawingModel aModel);
+ void RedrawPlugin();
+#ifdef XP_MACOSX
+ void SetEventModel(NPEventModel aModel);
+
+ void* GetCurrentEvent() {
+ return mCurrentPluginEvent;
+ }
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+ void NotifyForeground(bool aForeground);
+ void NotifyOnScreen(bool aOnScreen);
+ void MemoryPressure();
+ void NotifyFullScreen(bool aFullScreen);
+ void NotifySize(nsIntSize size);
+
+ nsIntSize CurrentSize() { return mCurrentSize; }
+
+ bool IsOnScreen() {
+ return mOnScreen;
+ }
+
+ uint32_t GetANPDrawingModel() { return mANPDrawingModel; }
+ void SetANPDrawingModel(uint32_t aModel);
+
+ void* GetJavaSurface();
+
+ void PostEvent(void* event);
+
+ // These are really mozilla::dom::ScreenOrientation, but it's
+ // difficult to include that here
+ uint32_t FullScreenOrientation() { return mFullScreenOrientation; }
+ void SetFullScreenOrientation(uint32_t orientation);
+
+ void SetWakeLock(bool aLock);
+
+ mozilla::gl::GLContext* GLContext();
+
+ // For ANPOpenGL
+ class TextureInfo {
+ public:
+ TextureInfo() :
+ mTexture(0), mWidth(0), mHeight(0), mInternalFormat(0)
+ {
+ }
+
+ TextureInfo(GLuint aTexture, int32_t aWidth, int32_t aHeight, GLuint aInternalFormat) :
+ mTexture(aTexture), mWidth(aWidth), mHeight(aHeight), mInternalFormat(aInternalFormat)
+ {
+ }
+
+ GLuint mTexture;
+ int32_t mWidth;
+ int32_t mHeight;
+ GLuint mInternalFormat;
+ };
+
+ // For ANPNativeWindow
+ void* AcquireContentWindow();
+
+ mozilla::gl::AndroidSurfaceTexture* AsSurfaceTexture();
+
+ // For ANPVideo
+ class VideoInfo {
+ public:
+ VideoInfo(mozilla::gl::AndroidSurfaceTexture* aSurfaceTexture) :
+ mSurfaceTexture(aSurfaceTexture)
+ {
+ }
+
+ ~VideoInfo()
+ {
+ mSurfaceTexture = nullptr;
+ }
+
+ RefPtr<mozilla::gl::AndroidSurfaceTexture> mSurfaceTexture;
+ gfxRect mDimensions;
+ };
+
+ void* AcquireVideoWindow();
+ void ReleaseVideoWindow(void* aWindow);
+ void SetVideoDimensions(void* aWindow, gfxRect aDimensions);
+
+ void GetVideos(nsTArray<VideoInfo*>& aVideos);
+
+ void SetOriginPos(mozilla::gl::OriginPos aOriginPos) {
+ mOriginPos = aOriginPos;
+ }
+ mozilla::gl::OriginPos OriginPos() const { return mOriginPos; }
+
+ static nsNPAPIPluginInstance* GetFromNPP(NPP npp);
+#endif
+
+ nsresult NewStreamListener(const char* aURL, void* notifyData,
+ nsNPAPIPluginStreamListener** listener);
+
+ nsNPAPIPluginInstance();
+
+ // To be called when an instance becomes orphaned, when
+ // it's plugin is no longer guaranteed to be around.
+ void Destroy();
+
+ // Indicates whether the plugin is running normally.
+ bool IsRunning() {
+ return RUNNING == mRunning;
+ }
+ bool HasStartedDestroying() {
+ return mRunning >= DESTROYING;
+ }
+
+ // Indicates whether the plugin is running normally or being shut down
+ bool CanFireNotifications() {
+ return mRunning == RUNNING || mRunning == DESTROYING;
+ }
+
+ // return is only valid when the plugin is not running
+ mozilla::TimeStamp StopTime();
+
+ // cache this NPAPI plugin
+ void SetCached(bool aCache);
+
+ already_AddRefed<nsPIDOMWindowOuter> GetDOMWindow();
+
+ nsresult PrivateModeStateChanged(bool aEnabled);
+
+ nsresult IsPrivateBrowsing(bool *aEnabled);
+
+ nsresult GetDOMElement(nsIDOMElement* *result);
+
+ nsNPAPITimer* TimerWithID(uint32_t id, uint32_t* index);
+ uint32_t ScheduleTimer(uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID));
+ void UnscheduleTimer(uint32_t timerID);
+ NPBool ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace);
+
+
+ nsTArray<nsNPAPIPluginStreamListener*> *StreamListeners();
+
+ nsTArray<nsPluginStreamListenerPeer*> *FileCachedStreamListeners();
+
+ nsresult AsyncSetWindow(NPWindow& window);
+
+ void URLRedirectResponse(void* notifyData, NPBool allow);
+
+ NPError InitAsyncSurface(NPSize *size, NPImageFormat format,
+ void *initData, NPAsyncSurface *surface);
+ NPError FinalizeAsyncSurface(NPAsyncSurface *surface);
+ void SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed);
+
+ // Called when the instance fails to instantiate beceause the Carbon
+ // event model is not supported.
+ void CarbonNPAPIFailure();
+
+ // Returns the contents scale factor of the screen the plugin is drawn on.
+ double GetContentsScaleFactor();
+
+ // Returns the css zoom factor of the document the plugin is drawn on.
+ float GetCSSZoomFactor();
+
+ nsresult GetRunID(uint32_t *aRunID);
+
+ static bool InPluginCallUnsafeForReentry() { return gInUnsafePluginCalls > 0; }
+ static void BeginPluginCall(NSPluginCallReentry aReentryState)
+ {
+ if (aReentryState == NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO) {
+ ++gInUnsafePluginCalls;
+ }
+ }
+ static void EndPluginCall(NSPluginCallReentry aReentryState)
+ {
+ if (aReentryState == NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO) {
+ NS_ASSERTION(gInUnsafePluginCalls > 0, "Must be in plugin call");
+ --gInUnsafePluginCalls;
+ }
+ }
+
+protected:
+
+ virtual ~nsNPAPIPluginInstance();
+
+ nsresult GetTagType(nsPluginTagType *result);
+ nsresult GetMode(int32_t *result);
+
+ // check if this is a Java applet and affected by bug 750480
+ void CheckJavaC2PJSObjectQuirk(uint16_t paramCount,
+ const char* const* names,
+ const char* const* values);
+
+ // The structure used to communicate between the plugin instance and
+ // the browser.
+ NPP_t mNPP;
+
+ NPDrawingModel mDrawingModel;
+
+#ifdef MOZ_WIDGET_ANDROID
+ uint32_t mANPDrawingModel;
+
+ friend class PluginEventRunnable;
+
+ nsTArray<RefPtr<PluginEventRunnable>> mPostedEvents;
+ void PopPostedEvent(PluginEventRunnable* r);
+ void OnSurfaceTextureFrameAvailable();
+
+ uint32_t mFullScreenOrientation;
+ bool mWakeLocked;
+ bool mFullScreen;
+ mozilla::gl::OriginPos mOriginPos;
+
+ RefPtr<mozilla::gl::AndroidSurfaceTexture> mContentSurface;
+#endif
+
+ enum {
+ NOT_STARTED,
+ RUNNING,
+ DESTROYING,
+ DESTROYED
+ } mRunning;
+
+ // these are used to store the windowless properties
+ // which the browser will later query
+ bool mWindowless;
+ bool mTransparent;
+ bool mCached;
+ bool mUsesDOMForCursor;
+
+public:
+ // True while creating the plugin, or calling NPP_SetWindow() on it.
+ bool mInPluginInitCall;
+
+ nsXPIDLCString mFakeURL;
+
+private:
+ RefPtr<nsNPAPIPlugin> mPlugin;
+
+ nsTArray<nsNPAPIPluginStreamListener*> mStreamListeners;
+
+ nsTArray<nsPluginStreamListenerPeer*> mFileCachedStreamListeners;
+
+ nsTArray<PopupControlState> mPopupStates;
+
+ char* mMIMEType;
+
+ // Weak pointer to the owner. The owner nulls this out (by calling
+ // InvalidateOwner()) when it's no longer our owner.
+ nsPluginInstanceOwner *mOwner;
+
+ nsTArray<nsNPAPITimer*> mTimers;
+
+#ifdef XP_MACOSX
+ // non-null during a HandleEvent call
+ void* mCurrentPluginEvent;
+#endif
+
+ // Timestamp for the last time this plugin was stopped.
+ // This is only valid when the plugin is actually stopped!
+ mozilla::TimeStamp mStopTime;
+
+#ifdef MOZ_WIDGET_ANDROID
+ already_AddRefed<mozilla::gl::AndroidSurfaceTexture> CreateSurfaceTexture();
+
+ std::map<void*, VideoInfo*> mVideos;
+ bool mOnScreen;
+
+ nsIntSize mCurrentSize;
+#endif
+
+ // is this instance Java and affected by bug 750480?
+ bool mHaveJavaC2PJSObjectQuirk;
+
+ static uint32_t gInUnsafePluginCalls;
+
+ // The arrays can only be released when the plugin instance is destroyed,
+ // because the plugin, in in-process mode, might keep a reference to them.
+ uint32_t mCachedParamLength;
+ char **mCachedParamNames;
+ char **mCachedParamValues;
+
+ nsCOMPtr<nsIAudioChannelAgent> mAudioChannelAgent;
+ bool mMuted;
+};
+
+// On Android, we need to guard against plugin code leaking entries in the local
+// JNI ref table. See https://bugzilla.mozilla.org/show_bug.cgi?id=780831#c21
+#ifdef MOZ_WIDGET_ANDROID
+ #define MAIN_THREAD_JNI_REF_GUARD mozilla::AutoLocalJNIFrame jniFrame
+#else
+ #define MAIN_THREAD_JNI_REF_GUARD
+#endif
+
+void NS_NotifyBeginPluginCall(NSPluginCallReentry aReentryState);
+void NS_NotifyPluginCall(NSPluginCallReentry aReentryState);
+
+#define NS_TRY_SAFE_CALL_RETURN(ret, fun, pluginInst, pluginCallReentry) \
+PR_BEGIN_MACRO \
+ MAIN_THREAD_JNI_REF_GUARD; \
+ NS_NotifyBeginPluginCall(pluginCallReentry); \
+ ret = fun; \
+ NS_NotifyPluginCall(pluginCallReentry); \
+PR_END_MACRO
+
+#define NS_TRY_SAFE_CALL_VOID(fun, pluginInst, pluginCallReentry) \
+PR_BEGIN_MACRO \
+ MAIN_THREAD_JNI_REF_GUARD; \
+ NS_NotifyBeginPluginCall(pluginCallReentry); \
+ fun; \
+ NS_NotifyPluginCall(pluginCallReentry); \
+PR_END_MACRO
+
+#endif // nsNPAPIPluginInstance_h_