nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/dom/plugins/ipc/PluginInstanceChild.h
Makoto Kato 897ea8c314 Bug 1438955 - Remove ImmReleaseContext hook. r=masayuki 
--HG--
extra : rebase_source : 78eeb24aa1b89c634cb9da089b43c01bdd390906
2018-03-07 11:01:30 +09:00

678 lines
24 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: sw=4 ts=4 et :
* 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 dom_plugins_PluginInstanceChild_h
#define dom_plugins_PluginInstanceChild_h 1
#include "mozilla/EventForwards.h"
#include "mozilla/plugins/PPluginInstanceChild.h"
#include "mozilla/plugins/PluginScriptableObjectChild.h"
#include "mozilla/plugins/StreamNotifyChild.h"
#include "mozilla/plugins/PPluginSurfaceChild.h"
#include "mozilla/ipc/CrossProcessMutex.h"
#include "nsRefPtrHashtable.h"
#if defined(OS_WIN)
#include "mozilla/gfx/SharedDIBWin.h"
#elif defined(MOZ_WIDGET_COCOA)
#include "PluginUtilsOSX.h"
#include "mozilla/gfx/QuartzSupport.h"
#include "base/timer.h"
#endif
#include "npfunctions.h"
#include "nsAutoPtr.h"
#include "nsTArray.h"
#include "ChildTimer.h"
#include "nsRect.h"
#include "nsTHashtable.h"
#include "mozilla/PaintTracker.h"
#include "mozilla/gfx/Types.h"
#include <map>
#ifdef MOZ_WIDGET_GTK
#include "gtk2xtbin.h"
#endif
class gfxASurface;
namespace mozilla {
namespace plugins {
class PBrowserStreamChild;
class BrowserStreamChild;
class StreamNotifyChild;
class PluginInstanceChild : public PPluginInstanceChild
{
friend class BrowserStreamChild;
friend class PluginStreamChild;
friend class StreamNotifyChild;
friend class PluginScriptableObjectChild;
#ifdef OS_WIN
friend LRESULT CALLBACK PluginWindowProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
static LRESULT CALLBACK PluginWindowProcInternal(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
#endif
protected:
virtual mozilla::ipc::IPCResult
AnswerCreateChildPluginWindow(NativeWindowHandle* aChildPluginWindow) override;
virtual mozilla::ipc::IPCResult
RecvCreateChildPopupSurrogate(const NativeWindowHandle& aNetscapeWindow) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_SetWindow(const NPRemoteWindow& window) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(bool* wantsAllStreams, NPError* rv) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_GetValue_NPPVpluginScriptableNPObject(PPluginScriptableObjectChild** value,
NPError* result) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(nsCString* aPlugId,
NPError* aResult) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value, NPError* result) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_SetValue_NPNVmuteAudioBool(const bool& value, NPError* result) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_SetValue_NPNVCSSZoomFactor(const double& value, NPError* result) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_HandleEvent(const NPRemoteEvent& event, int16_t* handled) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
Shmem&& mem,
int16_t* handled,
Shmem* rtnmem) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
const uint32_t& surface,
int16_t* handled) override;
// Async rendering
virtual mozilla::ipc::IPCResult
RecvAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
const NPRemoteWindow& aWindow) override;
virtual void
DoAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
const NPRemoteWindow& aWindow,
bool aIsAsync);
virtual PPluginSurfaceChild*
AllocPPluginSurfaceChild(const WindowsSharedMemoryHandle&,
const gfx::IntSize&, const bool&) override {
return new PPluginSurfaceChild();
}
virtual bool DeallocPPluginSurfaceChild(PPluginSurfaceChild* s) override {
delete s;
return true;
}
virtual mozilla::ipc::IPCResult
AnswerPaint(const NPRemoteEvent& event, int16_t* handled) override
{
PaintTracker pt;
if (!AnswerNPP_HandleEvent(event, handled)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
virtual mozilla::ipc::IPCResult
RecvWindowPosChanged(const NPRemoteEvent& event) override;
virtual mozilla::ipc::IPCResult
RecvContentsScaleFactorChanged(const double& aContentsScaleFactor) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_Destroy(NPError* result) override;
virtual PPluginScriptableObjectChild*
AllocPPluginScriptableObjectChild() override;
virtual bool
DeallocPPluginScriptableObjectChild(PPluginScriptableObjectChild* aObject) override;
virtual mozilla::ipc::IPCResult
RecvPPluginScriptableObjectConstructor(PPluginScriptableObjectChild* aActor) override;
virtual mozilla::ipc::IPCResult
RecvPBrowserStreamConstructor(PBrowserStreamChild* aActor, const nsCString& aURL,
const uint32_t& aLength, const uint32_t& aLastmodified,
PStreamNotifyChild* aNotifyData, const nsCString& aHeaders) override;
virtual mozilla::ipc::IPCResult
AnswerNPP_NewStream(
PBrowserStreamChild* actor,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t* stype) override;
virtual PBrowserStreamChild*
AllocPBrowserStreamChild(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
PStreamNotifyChild* notifyData,
const nsCString& headers) override;
virtual bool
DeallocPBrowserStreamChild(PBrowserStreamChild* stream) override;
virtual PStreamNotifyChild*
AllocPStreamNotifyChild(const nsCString& url, const nsCString& target,
const bool& post, const nsCString& buffer,
const bool& file,
NPError* result) override;
virtual bool
DeallocPStreamNotifyChild(PStreamNotifyChild* notifyData) override;
virtual mozilla::ipc::IPCResult
AnswerSetPluginFocus() override;
virtual mozilla::ipc::IPCResult
AnswerUpdateWindow() override;
virtual mozilla::ipc::IPCResult
RecvNPP_DidComposite() override;
public:
PluginInstanceChild(const NPPluginFuncs* aPluginIface,
const nsCString& aMimeType,
const InfallibleTArray<nsCString>& aNames,
const InfallibleTArray<nsCString>& aValues);
virtual ~PluginInstanceChild();
NPError DoNPP_New();
// Common sync+async implementation of NPP_NewStream
NPError DoNPP_NewStream(BrowserStreamChild* actor,
const nsCString& mimeType,
const bool& seekable,
uint16_t* stype);
bool Initialize();
NPP GetNPP()
{
return &mData;
}
NPError
NPN_GetValue(NPNVariable aVariable, void* aValue);
NPError
NPN_SetValue(NPPVariable aVariable, void* aValue);
PluginScriptableObjectChild*
GetActorForNPObject(NPObject* aObject);
NPError
NPN_NewStream(NPMIMEType aMIMEType, const char* aWindow,
NPStream** aStream);
void InvalidateRect(NPRect* aInvalidRect);
#ifdef MOZ_WIDGET_COCOA
void Invalidate();
#endif // definied(MOZ_WIDGET_COCOA)
uint32_t ScheduleTimer(uint32_t interval, bool repeat, TimerFunc func);
void UnscheduleTimer(uint32_t id);
int GetQuirks();
void NPN_URLRedirectResponse(void* notifyData, NPBool allow);
NPError NPN_InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface);
NPError NPN_FinalizeAsyncSurface(NPAsyncSurface *surface);
void NPN_SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed);
void DoAsyncRedraw();
virtual mozilla::ipc::IPCResult RecvHandledWindowedPluginKeyEvent(
const NativeEventData& aKeyEventData,
const bool& aIsConsumed) override;
#if defined(XP_WIN)
NPError DefaultAudioDeviceChanged(NPAudioDeviceChangeDetails& details);
#endif
private:
friend class PluginModuleChild;
NPError
InternalGetNPObjectForValue(NPNVariable aValue,
NPObject** aObject);
bool IsUsingDirectDrawing();
virtual mozilla::ipc::IPCResult RecvUpdateBackground(const SurfaceDescriptor& aBackground,
const nsIntRect& aRect) override;
virtual PPluginBackgroundDestroyerChild*
AllocPPluginBackgroundDestroyerChild() override;
virtual mozilla::ipc::IPCResult
RecvPPluginBackgroundDestroyerConstructor(PPluginBackgroundDestroyerChild* aActor) override;
virtual bool
DeallocPPluginBackgroundDestroyerChild(PPluginBackgroundDestroyerChild* aActor) override;
#if defined(OS_WIN)
static bool RegisterWindowClass();
bool CreatePluginWindow();
void DestroyPluginWindow();
void SizePluginWindow(int width, int height);
int16_t WinlessHandleEvent(NPEvent& event);
void CreateWinlessPopupSurrogate();
void DestroyWinlessPopupSurrogate();
void InitPopupMenuHook();
void SetupFlashMsgThrottle();
void UnhookWinlessFlashThrottle();
void HookSetWindowLongPtr();
void InitImm32Hook();
static inline bool SetWindowLongHookCheck(HWND hWnd,
int nIndex,
LONG_PTR newLong);
void FlashThrottleMessage(HWND, UINT, WPARAM, LPARAM, bool);
static LRESULT CALLBACK DummyWindowProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
static LRESULT CALLBACK PluginWindowProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
static BOOL WINAPI TrackPopupHookProc(HMENU hMenu,
UINT uFlags,
int x,
int y,
int nReserved,
HWND hWnd,
CONST RECT *prcRect);
static BOOL CALLBACK EnumThreadWindowsCallback(HWND hWnd,
LPARAM aParam);
static LRESULT CALLBACK WinlessHiddenFlashWndProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
#ifdef _WIN64
static LONG_PTR WINAPI SetWindowLongPtrAHook(HWND hWnd,
int nIndex,
LONG_PTR newLong);
static LONG_PTR WINAPI SetWindowLongPtrWHook(HWND hWnd,
int nIndex,
LONG_PTR newLong);
#else
static LONG WINAPI SetWindowLongAHook(HWND hWnd,
int nIndex,
LONG newLong);
static LONG WINAPI SetWindowLongWHook(HWND hWnd,
int nIndex,
LONG newLong);
#endif
static HIMC WINAPI ImmGetContextProc(HWND aWND);
static LONG WINAPI ImmGetCompositionStringProc(HIMC aIMC, DWORD aIndex,
LPVOID aBuf, DWORD aLen);
static BOOL WINAPI ImmSetCandidateWindowProc(HIMC hIMC,
LPCANDIDATEFORM plCandidate);
static BOOL WINAPI ImmNotifyIME(HIMC aIMC, DWORD aAction, DWORD aIndex,
DWORD aValue);
class FlashThrottleMsg : public CancelableRunnable
{
public:
FlashThrottleMsg(PluginInstanceChild* aInstance, HWND aWnd, UINT aMsg,
WPARAM aWParam, LPARAM aLParam, bool isWindowed)
: CancelableRunnable("FlashThrottleMsg"),
mInstance(aInstance),
mWnd(aWnd),
mMsg(aMsg),
mWParam(aWParam),
mLParam(aLParam),
mWindowed(isWindowed)
{}
NS_IMETHOD Run() override;
nsresult Cancel() override;
WNDPROC GetProc();
HWND GetWnd() { return mWnd; }
UINT GetMsg() { return mMsg; }
WPARAM GetWParam() { return mWParam; }
LPARAM GetLParam() { return mLParam; }
private:
PluginInstanceChild* mInstance;
HWND mWnd;
UINT mMsg;
WPARAM mWParam;
LPARAM mLParam;
bool mWindowed;
};
bool ShouldPostKeyMessage(UINT message, WPARAM wParam, LPARAM lParam);
bool MaybePostKeyMessage(UINT message, WPARAM wParam, LPARAM lParam);
#endif // #if defined(OS_WIN)
const NPPluginFuncs* mPluginIface;
nsCString mMimeType;
InfallibleTArray<nsCString> mNames;
InfallibleTArray<nsCString> mValues;
NPP_t mData;
NPWindow mWindow;
#if defined(XP_DARWIN) || defined(XP_WIN)
double mContentsScaleFactor;
#endif
double mCSSZoomFactor;
uint32_t mPostingKeyEvents;
uint32_t mPostingKeyEventsOutdated;
int16_t mDrawingModel;
NPAsyncSurface* mCurrentDirectSurface;
// The surface hashtables below serve a few purposes. They let us verify
// and retain extra information about plugin surfaces, and they let us
// free shared memory that the plugin might forget to release.
struct DirectBitmap {
DirectBitmap(PluginInstanceChild* aOwner, const Shmem& shmem,
const gfx::IntSize& size, uint32_t stride, SurfaceFormat format);
private:
~DirectBitmap();
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DirectBitmap);
PluginInstanceChild* mOwner;
Shmem mShmem;
gfx::SurfaceFormat mFormat;
gfx::IntSize mSize;
uint32_t mStride;
};
nsRefPtrHashtable<nsPtrHashKey<NPAsyncSurface>, DirectBitmap> mDirectBitmaps;
#if defined(XP_WIN)
nsDataHashtable<nsPtrHashKey<NPAsyncSurface>, WindowsHandle> mDxgiSurfaces;
#endif
mozilla::Mutex mAsyncInvalidateMutex;
CancelableRunnable *mAsyncInvalidateTask;
// Cached scriptable actors to avoid IPC churn
PluginScriptableObjectChild* mCachedWindowActor;
PluginScriptableObjectChild* mCachedElementActor;
#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
NPSetWindowCallbackStruct mWsInfo;
#ifdef MOZ_WIDGET_GTK
XtClient mXtClient;
#endif
#elif defined(OS_WIN)
HWND mPluginWindowHWND;
WNDPROC mPluginWndProc;
HWND mPluginParentHWND;
int mNestedEventLevelDepth;
HWND mCachedWinlessPluginHWND;
HWND mWinlessPopupSurrogateHWND;
nsIntPoint mPluginSize;
WNDPROC mWinlessThrottleOldWndProc;
HWND mWinlessHiddenMsgHWND;
#endif
#if defined(OS_WIN)
nsTArray<FlashThrottleMsg*> mPendingFlashThrottleMsgs;
#endif
nsTArray<nsAutoPtr<ChildTimer> > mTimers;
/**
* During destruction we enumerate all remaining scriptable objects and
* invalidate/delete them. Enumeration can re-enter, so maintain a
* hash separate from PluginModuleChild.mObjectMap.
*/
nsAutoPtr< nsTHashtable<DeletingObjectEntry> > mDeletingHash;
#if defined(MOZ_WIDGET_COCOA)
private:
#if defined(__i386__)
NPEventModel mEventModel;
#endif
CGColorSpaceRef mShColorSpace;
CGContextRef mShContext;
RefPtr<nsCARenderer> mCARenderer;
void *mCGLayer;
// Core Animation drawing model requires a refresh timer.
uint32_t mCARefreshTimer;
public:
const NPCocoaEvent* getCurrentEvent() {
return mCurrentEvent;
}
bool CGDraw(CGContextRef ref, nsIntRect aUpdateRect);
#if defined(__i386__)
NPEventModel EventModel() { return mEventModel; }
#endif
private:
const NPCocoaEvent *mCurrentEvent;
#endif
bool CanPaintOnBackground();
bool IsVisible() {
#ifdef XP_MACOSX
return mWindow.clipRect.top != mWindow.clipRect.bottom &&
mWindow.clipRect.left != mWindow.clipRect.right;
#else
return mWindow.clipRect.top != 0 ||
mWindow.clipRect.left != 0 ||
mWindow.clipRect.bottom != 0 ||
mWindow.clipRect.right != 0;
#endif
}
// ShowPluginFrame - in general does four things:
// 1) Create mCurrentSurface optimized for rendering to parent process
// 2) Updated mCurrentSurface to be a complete copy of mBackSurface
// 3) Draw the invalidated plugin area into mCurrentSurface
// 4) Send it to parent process.
bool ShowPluginFrame(void);
// If we can read back safely from mBackSurface, copy
// mSurfaceDifferenceRect from mBackSurface to mFrontSurface.
// @return Whether the back surface could be read.
bool ReadbackDifferenceRect(const nsIntRect& rect);
// Post ShowPluginFrame task
void AsyncShowPluginFrame(void);
// In the PaintRect functions, aSurface is the size of the full plugin
// window. Each PaintRect function renders into the subrectangle aRect of
// aSurface (possibly more if we're working around a Flash bug).
// Paint plugin content rectangle to surface with bg color filling
void PaintRectToSurface(const nsIntRect& aRect,
gfxASurface* aSurface,
const gfx::Color& aColor);
// Render plugin content to surface using
// white/black image alpha extraction algorithm
void PaintRectWithAlphaExtraction(const nsIntRect& aRect,
gfxASurface* aSurface);
// Call plugin NPAPI function to render plugin content to surface
// @param - aSurface - should be compatible with current platform plugin rendering
// @return - FALSE if plugin not painted to surface
void PaintRectToPlatformSurface(const nsIntRect& aRect,
gfxASurface* aSurface);
// Update NPWindow platform attributes and call plugin "setwindow"
// @param - aForceSetWindow - call setwindow even if platform attributes are the same
void UpdateWindowAttributes(bool aForceSetWindow = false);
// Create optimized mCurrentSurface for parent process rendering
// @return FALSE if optimized surface not created
bool CreateOptSurface(void);
// Create mHelperSurface if mCurrentSurface non compatible with plugins
// @return TRUE if helper surface created successfully, or not needed
bool MaybeCreatePlatformHelperSurface(void);
// Make sure that we have surface for rendering
bool EnsureCurrentBuffer(void);
// Helper function for delayed InvalidateRect call
// non null mCurrentInvalidateTask will call this function
void InvalidateRectDelayed(void);
// Clear mCurrentSurface/mCurrentSurfaceActor/mHelperSurface
void ClearCurrentSurface();
// Swap mCurrentSurface/mBackSurface and their associated actors
void SwapSurfaces();
// Clear all surfaces in response to NPP_Destroy
void ClearAllSurfaces();
void Destroy();
void ActorDestroy(ActorDestroyReason aWhy) override;
// Set as true when SetupLayer called
// and go with different path in InvalidateRect function
bool mLayersRendering;
// Current surface available for rendering
RefPtr<gfxASurface> mCurrentSurface;
// Back surface, just keeping reference to
// surface which is on ParentProcess side
RefPtr<gfxASurface> mBackSurface;
#ifdef XP_MACOSX
// Current IOSurface available for rendering
// We can't use thebes gfxASurface like other platforms.
PluginUtilsOSX::nsDoubleBufferCARenderer mDoubleBufferCARenderer;
#endif
// (Not to be confused with mBackSurface). This is a recent copy
// of the opaque pixels under our object frame, if
// |mIsTransparent|. We ask the plugin render directly onto a
// copy of the background pixels if available, and fall back on
// alpha recovery otherwise.
RefPtr<gfxASurface> mBackground;
#ifdef XP_WIN
// These actors mirror mCurrentSurface/mBackSurface
PPluginSurfaceChild* mCurrentSurfaceActor;
PPluginSurfaceChild* mBackSurfaceActor;
#endif
// Accumulated invalidate rect, while back buffer is not accessible,
// in plugin coordinates.
nsIntRect mAccumulatedInvalidRect;
// Plugin only call SetTransparent
// and does not remember their transparent state
// and p->getvalue return always false
bool mIsTransparent;
// Surface type optimized of parent process
gfxSurfaceType mSurfaceType;
// Keep InvalidateRect task pointer to be able Cancel it on Destroy
RefPtr<CancelableRunnable> mCurrentInvalidateTask;
// Keep AsyncSetWindow task pointer to be able to Cancel it on Destroy
RefPtr<CancelableRunnable> mCurrentAsyncSetWindowTask;
// True while plugin-child in plugin call
// Use to prevent plugin paint re-enter
bool mPendingPluginCall;
// On some platforms, plugins may not support rendering to a surface with
// alpha, or not support rendering to an image surface.
// In those cases we need to draw to a temporary platform surface; we cache
// that surface here.
RefPtr<gfxASurface> mHelperSurface;
// true when plugin does not support painting to ARGB32
// surface this is false if plugin supports
// NPPVpluginTransparentAlphaBool (which is not part of
// NPAPI yet)
bool mDoAlphaExtraction;
// true when the plugin has painted at least once. We use this to ensure
// that we ask a plugin to paint at least once even if it's invisible;
// some plugin (instances) rely on this in order to work properly.
bool mHasPainted;
// Cached rectangle rendered to previous surface(mBackSurface)
// Used for reading back to current surface and syncing data,
// in plugin coordinates.
nsIntRect mSurfaceDifferenceRect;
// Has this instance been destroyed, either by ActorDestroy or NPP_Destroy?
bool mDestroyed;
#ifdef XP_WIN
// WM_*CHAR messages are never consumed by chrome process's widget.
// So, if preceding keydown or keyup event is consumed by reserved
// shortcut key in the chrome process, we shouldn't send the following
// WM_*CHAR messages to the plugin.
bool mLastKeyEventConsumed;
#endif // #ifdef XP_WIN
// While IME in the process has composition, this is set to true.
// Otherwise, false.
static bool sIsIMEComposing;
// A counter is incremented by AutoStackHelper to indicate that there is an
// active plugin call which should be preventing shutdown.
public:
class AutoStackHelper {
public:
explicit AutoStackHelper(PluginInstanceChild* instance)
: mInstance(instance)
{
++mInstance->mStackDepth;
}
~AutoStackHelper() {
--mInstance->mStackDepth;
}
private:
PluginInstanceChild *const mInstance;
};
private:
int32_t mStackDepth;
};
} // namespace plugins
} // namespace mozilla
#endif // ifndef dom_plugins_PluginInstanceChild_h
View git blame Copy permalink