зеркало из https://github.com/mozilla/gecko-dev.git
661 строка
22 KiB
C++
661 строка
22 KiB
C++
/* -*- 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/. */
|
|
|
|
#include "mozilla/BasicEvents.h"
|
|
#include "mozilla/DebugOnly.h"
|
|
#include "mozilla/WeakPtr.h"
|
|
|
|
#include "windows.h"
|
|
#include "windowsx.h"
|
|
|
|
// XXXbz windowsx.h defines GetFirstChild, GetNextSibling,
|
|
// GetPrevSibling are macros, apparently... Eeevil. We have functions
|
|
// called that on some classes, so undef them.
|
|
#undef GetFirstChild
|
|
#undef GetNextSibling
|
|
#undef GetPrevSibling
|
|
|
|
#include "nsDebug.h"
|
|
|
|
#include "nsWindowsDllInterceptor.h"
|
|
#include "nsPluginNativeWindow.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsCrashOnException.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
#define NP_POPUP_API_VERSION 16
|
|
|
|
#define nsMajorVersion(v) (((int32_t)(v) >> 16) & 0xffff)
|
|
#define nsMinorVersion(v) ((int32_t)(v)&0xffff)
|
|
#define versionOK(suppliedV, requiredV) \
|
|
(nsMajorVersion(suppliedV) == nsMajorVersion(requiredV) && \
|
|
nsMinorVersion(suppliedV) >= nsMinorVersion(requiredV))
|
|
|
|
#define NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION \
|
|
TEXT("MozillaPluginWindowPropertyAssociation")
|
|
#define NS_PLUGIN_CUSTOM_MSG_ID TEXT("MozFlashUserRelay")
|
|
#define WM_USER_FLASH WM_USER + 1
|
|
static UINT sWM_FLASHBOUNCEMSG = 0;
|
|
|
|
class nsPluginNativeWindowWin;
|
|
|
|
/**
|
|
* PLEvent handling code
|
|
*/
|
|
class PluginWindowEvent : public Runnable {
|
|
public:
|
|
PluginWindowEvent();
|
|
void Init(WeakPtr<nsPluginNativeWindowWin> aRef, HWND aWnd, UINT aMsg,
|
|
WPARAM aParam, LPARAM aLParam);
|
|
void Clear();
|
|
HWND GetWnd() { return mWnd; };
|
|
UINT GetMsg() { return mMsg; };
|
|
WPARAM GetWParam() { return mWParam; };
|
|
LPARAM GetLParam() { return mLParam; };
|
|
bool InUse() { return mWnd != nullptr; };
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
protected:
|
|
WeakPtr<nsPluginNativeWindowWin> mPluginWindowRef;
|
|
HWND mWnd;
|
|
UINT mMsg;
|
|
WPARAM mWParam;
|
|
LPARAM mLParam;
|
|
};
|
|
|
|
PluginWindowEvent::PluginWindowEvent() : Runnable("PluginWindowEvent") {
|
|
Clear();
|
|
}
|
|
|
|
void PluginWindowEvent::Clear() {
|
|
mWnd = nullptr;
|
|
mMsg = 0;
|
|
mWParam = 0;
|
|
mLParam = 0;
|
|
}
|
|
|
|
void PluginWindowEvent::Init(WeakPtr<nsPluginNativeWindowWin> aRef, HWND aWnd,
|
|
UINT aMsg, WPARAM aWParam, LPARAM aLParam) {
|
|
NS_ASSERTION(aWnd != nullptr, "invalid plugin event value");
|
|
NS_ASSERTION(mWnd == nullptr, "event already in use");
|
|
mPluginWindowRef = aRef;
|
|
mWnd = aWnd;
|
|
mMsg = aMsg;
|
|
mWParam = aWParam;
|
|
mLParam = aLParam;
|
|
}
|
|
|
|
/**
|
|
* nsPluginNativeWindow Windows specific class declaration
|
|
*/
|
|
|
|
class nsPluginNativeWindowWin
|
|
: public nsPluginNativeWindow,
|
|
public SupportsWeakPtr<nsPluginNativeWindowWin> {
|
|
public:
|
|
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsPluginNativeWindowWin)
|
|
nsPluginNativeWindowWin();
|
|
|
|
virtual nsresult CallSetWindow(
|
|
RefPtr<nsNPAPIPluginInstance>& aPluginInstance);
|
|
|
|
private:
|
|
nsresult SubclassAndAssociateWindow();
|
|
nsresult UndoSubclassAndAssociateWindow();
|
|
|
|
public:
|
|
// locals
|
|
WNDPROC GetPrevWindowProc();
|
|
void SetPrevWindowProc(WNDPROC proc) { mPluginWinProc = proc; }
|
|
WNDPROC GetWindowProc();
|
|
PluginWindowEvent* GetPluginWindowEvent(HWND aWnd, UINT aMsg, WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
private:
|
|
WNDPROC mPluginWinProc;
|
|
WNDPROC mPrevWinProc;
|
|
WeakPtr<nsPluginNativeWindowWin> mWeakRef;
|
|
RefPtr<PluginWindowEvent> mCachedPluginWindowEvent;
|
|
|
|
HWND mParentWnd;
|
|
LONG_PTR mParentProc;
|
|
|
|
public:
|
|
nsPluginHost::SpecialType mPluginType;
|
|
};
|
|
|
|
static bool sInPreviousMessageDispatch = false;
|
|
|
|
static bool ProcessFlashMessageDelayed(nsPluginNativeWindowWin* aWin,
|
|
nsNPAPIPluginInstance* aInst, HWND hWnd,
|
|
UINT msg, WPARAM wParam, LPARAM lParam) {
|
|
NS_ENSURE_TRUE(aWin, false);
|
|
NS_ENSURE_TRUE(aInst, false);
|
|
|
|
if (msg == sWM_FLASHBOUNCEMSG) {
|
|
// See PluginWindowEvent::Run() below.
|
|
NS_ASSERTION((sWM_FLASHBOUNCEMSG != 0),
|
|
"RegisterWindowMessage failed in flash plugin WM_USER message "
|
|
"handling!");
|
|
::CallWindowProc((WNDPROC)aWin->GetWindowProc(), hWnd, WM_USER_FLASH,
|
|
wParam, lParam);
|
|
return true;
|
|
}
|
|
|
|
if (msg != WM_USER_FLASH) return false; // no need to delay
|
|
|
|
// do stuff
|
|
nsCOMPtr<nsIRunnable> pwe =
|
|
aWin->GetPluginWindowEvent(hWnd, msg, wParam, lParam);
|
|
if (pwe) {
|
|
NS_DispatchToCurrentThread(pwe);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class nsDelayedPopupsEnabledEvent : public Runnable {
|
|
public:
|
|
explicit nsDelayedPopupsEnabledEvent(nsNPAPIPluginInstance* inst)
|
|
: Runnable("nsDelayedPopupsEnabledEvent"), mInst(inst) {}
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
private:
|
|
RefPtr<nsNPAPIPluginInstance> mInst;
|
|
};
|
|
|
|
NS_IMETHODIMP nsDelayedPopupsEnabledEvent::Run() {
|
|
mInst->PushPopupsEnabledState(false);
|
|
return NS_OK;
|
|
}
|
|
|
|
static LRESULT CALLBACK PluginWndProc(HWND hWnd, UINT msg, WPARAM wParam,
|
|
LPARAM lParam);
|
|
|
|
/**
|
|
* New plugin window procedure
|
|
*
|
|
* e10s note - this subclass, and the hooks we set below using
|
|
* WindowsDllInterceptor are currently not in use when running with e10s.
|
|
* (Utility calls like CallSetWindow are still in use in the content process.)
|
|
* We would like to keep things this away, essentially making all the hacks here
|
|
* obsolete. Some of the mitigation work here has already been supplanted by
|
|
* code in PluginInstanceChild. The rest we eventually want to rip out.
|
|
*/
|
|
static LRESULT CALLBACK PluginWndProcInternal(HWND hWnd, UINT msg,
|
|
WPARAM wParam, LPARAM lParam) {
|
|
nsPluginNativeWindowWin* win = (nsPluginNativeWindowWin*)::GetProp(
|
|
hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
if (!win) return TRUE;
|
|
|
|
// The DispatchEvent(ePluginActivate) below can trigger a reentrant focus
|
|
// event which might destroy us. Hold a strong ref on the plugin instance
|
|
// to prevent that, bug 374229.
|
|
RefPtr<nsNPAPIPluginInstance> inst;
|
|
win->GetPluginInstance(inst);
|
|
|
|
bool enablePopups = false;
|
|
|
|
// Activate/deactivate mouse capture on the plugin widget
|
|
// here, before we pass the Windows event to the plugin
|
|
// because its possible our widget won't get paired events
|
|
// (see bug 131007) and we'll look frozen. Note that this
|
|
// is also done in ChildWindow::DispatchMouseEvent.
|
|
switch (msg) {
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_RBUTTONDOWN: {
|
|
nsCOMPtr<nsIWidget> widget;
|
|
win->GetPluginWidget(getter_AddRefs(widget));
|
|
if (widget) widget->CaptureMouse(true);
|
|
break;
|
|
}
|
|
case WM_LBUTTONUP:
|
|
enablePopups = true;
|
|
|
|
// fall through
|
|
case WM_MBUTTONUP:
|
|
case WM_RBUTTONUP: {
|
|
nsCOMPtr<nsIWidget> widget;
|
|
win->GetPluginWidget(getter_AddRefs(widget));
|
|
if (widget) widget->CaptureMouse(false);
|
|
break;
|
|
}
|
|
case WM_KEYDOWN:
|
|
// Ignore repeating keydown messages...
|
|
if ((lParam & 0x40000000) != 0) {
|
|
break;
|
|
}
|
|
|
|
// fall through
|
|
case WM_KEYUP:
|
|
enablePopups = true;
|
|
|
|
break;
|
|
|
|
case WM_MOUSEACTIVATE: {
|
|
// If a child window of this plug-in is already focused,
|
|
// don't focus the parent to avoid focus dance. We'll
|
|
// receive a follow up WM_SETFOCUS which will notify
|
|
// the appropriate window anyway.
|
|
HWND focusedWnd = ::GetFocus();
|
|
if (!::IsChild((HWND)win->window, focusedWnd)) {
|
|
// Notify the dom / focus manager the plugin has focus when one of
|
|
// it's child windows receives it. OOPP specific - this code is
|
|
// critical in notifying the dom of focus changes when the plugin
|
|
// window in the child process receives focus via a mouse click.
|
|
// WM_MOUSEACTIVATE is sent by nsWindow via a custom window event
|
|
// sent from PluginInstanceParent in response to focus events sent
|
|
// from the child. (bug 540052) Note, this gui event could also be
|
|
// sent directly from widget.
|
|
nsCOMPtr<nsIWidget> widget;
|
|
win->GetPluginWidget(getter_AddRefs(widget));
|
|
if (widget) {
|
|
WidgetGUIEvent event(true, ePluginActivate, widget);
|
|
nsEventStatus status;
|
|
widget->DispatchEvent(&event, status);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case WM_SETFOCUS:
|
|
case WM_KILLFOCUS: {
|
|
// Make sure setfocus and killfocus get through to the widget procedure
|
|
// even if they are eaten by the plugin. Also make sure we aren't calling
|
|
// recursively.
|
|
WNDPROC prevWndProc = win->GetPrevWindowProc();
|
|
if (prevWndProc && !sInPreviousMessageDispatch) {
|
|
sInPreviousMessageDispatch = true;
|
|
::CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
|
|
sInPreviousMessageDispatch = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Macromedia Flash plugin may flood the message queue with some special
|
|
// messages (WM_USER+1) causing 100% CPU consumption and GUI freeze, see
|
|
// mozilla bug 132759; we can prevent this from happening by delaying the
|
|
// processing such messages;
|
|
if (win->mPluginType == nsPluginHost::eSpecialType_Flash) {
|
|
if (ProcessFlashMessageDelayed(win, inst, hWnd, msg, wParam, lParam))
|
|
return TRUE;
|
|
}
|
|
|
|
if (enablePopups && inst) {
|
|
uint16_t apiVersion;
|
|
if (NS_SUCCEEDED(inst->GetPluginAPIVersion(&apiVersion)) &&
|
|
!versionOK(apiVersion, NP_POPUP_API_VERSION)) {
|
|
inst->PushPopupsEnabledState(true);
|
|
}
|
|
}
|
|
|
|
LRESULT res;
|
|
WNDPROC proc = (WNDPROC)win->GetWindowProc();
|
|
if (PluginWndProc == proc) {
|
|
NS_WARNING(
|
|
"Previous plugin window procedure references PluginWndProc! "
|
|
"Report this bug!");
|
|
res = CallWindowProc(DefWindowProc, hWnd, msg, wParam, lParam);
|
|
} else {
|
|
res = CallWindowProc(proc, hWnd, msg, wParam, lParam);
|
|
}
|
|
|
|
if (inst) {
|
|
// Popups are enabled (were enabled before the call to
|
|
// CallWindowProc()). Some plugins (at least the flash player)
|
|
// post messages from their key handlers etc that delay the actual
|
|
// processing, so we need to delay the disabling of popups so that
|
|
// popups remain enabled when the flash player ends up processing
|
|
// the actual key handlers. We do this by posting an event that
|
|
// does the disabling, this way our disabling will happen after
|
|
// the handlers in the plugin are done.
|
|
|
|
// Note that it's not fatal if any of this fails (which won't
|
|
// happen unless we're out of memory anyways) since the plugin
|
|
// code will pop any popup state pushed by this plugin on
|
|
// destruction.
|
|
|
|
nsCOMPtr<nsIRunnable> event = new nsDelayedPopupsEnabledEvent(inst);
|
|
if (event) NS_DispatchToCurrentThread(event);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static LRESULT CALLBACK PluginWndProc(HWND hWnd, UINT msg, WPARAM wParam,
|
|
LPARAM lParam) {
|
|
return mozilla::CallWindowProcCrashProtected(PluginWndProcInternal, hWnd, msg,
|
|
wParam, lParam);
|
|
}
|
|
|
|
/*
|
|
* Flash will reset the subclass of our widget at various times.
|
|
* (Notably when entering and exiting full screen mode.) This
|
|
* occurs independent of the main plugin window event procedure.
|
|
* We trap these subclass calls to prevent our subclass hook from
|
|
* getting dropped.
|
|
* Note, ascii versions can be nixed once flash versions < 10.1
|
|
* are considered obsolete.
|
|
*/
|
|
static WindowsDllInterceptor sUser32Intercept;
|
|
|
|
#ifdef _WIN64
|
|
typedef LONG_PTR(WINAPI* User32SetWindowLongPtrA)(HWND hWnd, int nIndex,
|
|
LONG_PTR dwNewLong);
|
|
typedef LONG_PTR(WINAPI* User32SetWindowLongPtrW)(HWND hWnd, int nIndex,
|
|
LONG_PTR dwNewLong);
|
|
static WindowsDllInterceptor::FuncHookType<User32SetWindowLongPtrA>
|
|
sUser32SetWindowLongAHookStub;
|
|
static WindowsDllInterceptor::FuncHookType<User32SetWindowLongPtrW>
|
|
sUser32SetWindowLongWHookStub;
|
|
#else
|
|
typedef LONG(WINAPI* User32SetWindowLongA)(HWND hWnd, int nIndex,
|
|
LONG dwNewLong);
|
|
typedef LONG(WINAPI* User32SetWindowLongW)(HWND hWnd, int nIndex,
|
|
LONG dwNewLong);
|
|
static WindowsDllInterceptor::FuncHookType<User32SetWindowLongA>
|
|
sUser32SetWindowLongAHookStub;
|
|
static WindowsDllInterceptor::FuncHookType<User32SetWindowLongW>
|
|
sUser32SetWindowLongWHookStub;
|
|
#endif
|
|
static inline bool SetWindowLongHookCheck(HWND hWnd, int nIndex,
|
|
LONG_PTR newLong) {
|
|
nsPluginNativeWindowWin* win = (nsPluginNativeWindowWin*)GetProp(
|
|
hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
if (!win || (win && win->mPluginType != nsPluginHost::eSpecialType_Flash) ||
|
|
(nIndex == GWLP_WNDPROC &&
|
|
newLong == reinterpret_cast<LONG_PTR>(PluginWndProc)))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
LONG_PTR WINAPI SetWindowLongPtrAHook(HWND hWnd, int nIndex, LONG_PTR newLong)
|
|
#else
|
|
LONG WINAPI SetWindowLongAHook(HWND hWnd, int nIndex, LONG newLong)
|
|
#endif
|
|
{
|
|
if (SetWindowLongHookCheck(hWnd, nIndex, newLong))
|
|
return sUser32SetWindowLongAHookStub(hWnd, nIndex, newLong);
|
|
|
|
// Set flash's new subclass to get the result.
|
|
LONG_PTR proc = sUser32SetWindowLongAHookStub(hWnd, nIndex, newLong);
|
|
|
|
// We already checked this in SetWindowLongHookCheck
|
|
nsPluginNativeWindowWin* win = (nsPluginNativeWindowWin*)GetProp(
|
|
hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
|
|
// Hook our subclass back up, just like we do on setwindow.
|
|
win->SetPrevWindowProc(
|
|
reinterpret_cast<WNDPROC>(sUser32SetWindowLongWHookStub(
|
|
hWnd, nIndex, reinterpret_cast<LONG_PTR>(PluginWndProc))));
|
|
return proc;
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
LONG_PTR WINAPI SetWindowLongPtrWHook(HWND hWnd, int nIndex, LONG_PTR newLong)
|
|
#else
|
|
LONG WINAPI SetWindowLongWHook(HWND hWnd, int nIndex, LONG newLong)
|
|
#endif
|
|
{
|
|
if (SetWindowLongHookCheck(hWnd, nIndex, newLong))
|
|
return sUser32SetWindowLongWHookStub(hWnd, nIndex, newLong);
|
|
|
|
// Set flash's new subclass to get the result.
|
|
LONG_PTR proc = sUser32SetWindowLongWHookStub(hWnd, nIndex, newLong);
|
|
|
|
// We already checked this in SetWindowLongHookCheck
|
|
nsPluginNativeWindowWin* win = (nsPluginNativeWindowWin*)GetProp(
|
|
hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
|
|
// Hook our subclass back up, just like we do on setwindow.
|
|
win->SetPrevWindowProc(
|
|
reinterpret_cast<WNDPROC>(sUser32SetWindowLongWHookStub(
|
|
hWnd, nIndex, reinterpret_cast<LONG_PTR>(PluginWndProc))));
|
|
return proc;
|
|
}
|
|
|
|
static void HookSetWindowLongPtr() {
|
|
sUser32Intercept.Init("user32.dll");
|
|
#ifdef _WIN64
|
|
sUser32SetWindowLongAHookStub.Set(sUser32Intercept, "SetWindowLongPtrA",
|
|
&SetWindowLongPtrAHook);
|
|
sUser32SetWindowLongWHookStub.Set(sUser32Intercept, "SetWindowLongPtrW",
|
|
&SetWindowLongPtrWHook);
|
|
#else
|
|
sUser32SetWindowLongAHookStub.Set(sUser32Intercept, "SetWindowLongA",
|
|
&SetWindowLongAHook);
|
|
sUser32SetWindowLongWHookStub.Set(sUser32Intercept, "SetWindowLongW",
|
|
&SetWindowLongWHook);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* nsPluginNativeWindowWin implementation
|
|
*/
|
|
nsPluginNativeWindowWin::nsPluginNativeWindowWin() : nsPluginNativeWindow() {
|
|
// initialize the struct fields
|
|
window = nullptr;
|
|
x = 0;
|
|
y = 0;
|
|
width = 0;
|
|
height = 0;
|
|
type = NPWindowTypeWindow;
|
|
|
|
mPrevWinProc = nullptr;
|
|
mPluginWinProc = nullptr;
|
|
mPluginType = nsPluginHost::eSpecialType_None;
|
|
|
|
mParentWnd = nullptr;
|
|
mParentProc = 0;
|
|
}
|
|
|
|
WNDPROC nsPluginNativeWindowWin::GetPrevWindowProc() { return mPrevWinProc; }
|
|
|
|
WNDPROC nsPluginNativeWindowWin::GetWindowProc() { return mPluginWinProc; }
|
|
|
|
NS_IMETHODIMP PluginWindowEvent::Run() {
|
|
nsPluginNativeWindowWin* win = mPluginWindowRef;
|
|
if (!win) return NS_OK;
|
|
|
|
HWND hWnd = GetWnd();
|
|
if (!hWnd) return NS_OK;
|
|
|
|
RefPtr<nsNPAPIPluginInstance> inst;
|
|
win->GetPluginInstance(inst);
|
|
|
|
if (GetMsg() == WM_USER_FLASH) {
|
|
// XXX Unwind issues related to runnable event callback depth for this
|
|
// event and destruction of the plugin. (Bug 493601)
|
|
::PostMessage(hWnd, sWM_FLASHBOUNCEMSG, GetWParam(), GetLParam());
|
|
} else {
|
|
// Currently not used, but added so that processing events here
|
|
// is more generic.
|
|
::CallWindowProc(win->GetWindowProc(), hWnd, GetMsg(), GetWParam(),
|
|
GetLParam());
|
|
}
|
|
|
|
Clear();
|
|
return NS_OK;
|
|
}
|
|
|
|
PluginWindowEvent* nsPluginNativeWindowWin::GetPluginWindowEvent(
|
|
HWND aWnd, UINT aMsg, WPARAM aWParam, LPARAM aLParam) {
|
|
if (!mWeakRef) {
|
|
mWeakRef = this;
|
|
if (!mWeakRef) return nullptr;
|
|
}
|
|
|
|
PluginWindowEvent* event;
|
|
|
|
// We have the ability to alloc if needed in case in the future some plugin
|
|
// should post multiple PostMessages. However, this could lead to many
|
|
// alloc's per second which could become a performance issue. See bug 169247.
|
|
if (!mCachedPluginWindowEvent) {
|
|
event = new PluginWindowEvent();
|
|
mCachedPluginWindowEvent = event;
|
|
} else if (mCachedPluginWindowEvent->InUse()) {
|
|
event = new PluginWindowEvent();
|
|
} else {
|
|
event = mCachedPluginWindowEvent;
|
|
}
|
|
|
|
event->Init(mWeakRef, aWnd, aMsg, aWParam, aLParam);
|
|
return event;
|
|
}
|
|
|
|
nsresult nsPluginNativeWindowWin::CallSetWindow(
|
|
RefPtr<nsNPAPIPluginInstance>& aPluginInstance) {
|
|
// Note, 'window' can be null
|
|
|
|
// check the incoming instance, null indicates that window is going away and
|
|
// we are not interested in subclassing business any more, undo and don't
|
|
// subclass
|
|
if (!aPluginInstance) {
|
|
UndoSubclassAndAssociateWindow();
|
|
// release plugin instance
|
|
SetPluginInstance(nullptr);
|
|
nsPluginNativeWindow::CallSetWindow(aPluginInstance);
|
|
return NS_OK;
|
|
}
|
|
|
|
// check plugin mime type and cache it if it will need special treatment later
|
|
if (mPluginType == nsPluginHost::eSpecialType_None) {
|
|
const char* mimetype = nullptr;
|
|
if (NS_SUCCEEDED(aPluginInstance->GetMIMEType(&mimetype)) && mimetype) {
|
|
mPluginType = nsPluginHost::GetSpecialType(nsDependentCString(mimetype));
|
|
}
|
|
}
|
|
|
|
// With e10s we execute in the content process and as such we don't
|
|
// have access to native widgets. CallSetWindow and skip native widget
|
|
// subclassing.
|
|
if (!XRE_IsParentProcess()) {
|
|
nsPluginNativeWindow::CallSetWindow(aPluginInstance);
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!sWM_FLASHBOUNCEMSG) {
|
|
sWM_FLASHBOUNCEMSG = ::RegisterWindowMessage(NS_PLUGIN_CUSTOM_MSG_ID);
|
|
}
|
|
|
|
if (window) {
|
|
// grab the widget procedure before the plug-in does a subclass in
|
|
// setwindow. We'll use this in PluginWndProc for forwarding focus
|
|
// events to the widget.
|
|
WNDPROC currentWndProc =
|
|
(WNDPROC)::GetWindowLongPtr((HWND)window, GWLP_WNDPROC);
|
|
if (!mPrevWinProc && currentWndProc != PluginWndProc)
|
|
mPrevWinProc = currentWndProc;
|
|
}
|
|
|
|
nsPluginNativeWindow::CallSetWindow(aPluginInstance);
|
|
|
|
SubclassAndAssociateWindow();
|
|
|
|
if (window && mPluginType == nsPluginHost::eSpecialType_Flash &&
|
|
!GetPropW((HWND)window, L"PluginInstanceParentProperty")) {
|
|
HookSetWindowLongPtr();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsPluginNativeWindowWin::SubclassAndAssociateWindow() {
|
|
if (type != NPWindowTypeWindow || !window) return NS_ERROR_FAILURE;
|
|
|
|
HWND hWnd = (HWND)window;
|
|
|
|
// check if we need to subclass
|
|
WNDPROC currentWndProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
if (currentWndProc == PluginWndProc) return NS_OK;
|
|
|
|
// If the plugin reset the subclass, set it back.
|
|
if (mPluginWinProc) {
|
|
#ifdef DEBUG
|
|
NS_WARNING("A plugin cleared our subclass - resetting.");
|
|
if (currentWndProc != mPluginWinProc) {
|
|
NS_WARNING("Procedures do not match up, discarding old subclass value.");
|
|
}
|
|
if (mPrevWinProc && currentWndProc == mPrevWinProc) {
|
|
NS_WARNING("The new procedure is our widget procedure?");
|
|
}
|
|
#endif
|
|
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)PluginWndProc);
|
|
return NS_OK;
|
|
}
|
|
|
|
LONG_PTR style = GetWindowLongPtr(hWnd, GWL_STYLE);
|
|
// Out of process plugins must not have the WS_CLIPCHILDREN style set on their
|
|
// parent windows or else synchronous paints (via UpdateWindow() and others)
|
|
// will cause deadlocks.
|
|
if (::GetPropW(hWnd, L"PluginInstanceParentProperty"))
|
|
style &= ~WS_CLIPCHILDREN;
|
|
else
|
|
style |= WS_CLIPCHILDREN;
|
|
SetWindowLongPtr(hWnd, GWL_STYLE, style);
|
|
|
|
mPluginWinProc =
|
|
(WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)PluginWndProc);
|
|
if (!mPluginWinProc) return NS_ERROR_FAILURE;
|
|
|
|
DebugOnly<nsPluginNativeWindowWin*> win = (nsPluginNativeWindowWin*)::GetProp(
|
|
hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
NS_ASSERTION(!win || (win == this),
|
|
"plugin window already has property and this is not us");
|
|
|
|
if (!::SetProp(hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION, (HANDLE)this))
|
|
return NS_ERROR_FAILURE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsPluginNativeWindowWin::UndoSubclassAndAssociateWindow() {
|
|
// remove window property
|
|
HWND hWnd = (HWND)window;
|
|
if (IsWindow(hWnd)) ::RemoveProp(hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
|
|
// restore the original win proc
|
|
// but only do this if this were us last time
|
|
if (mPluginWinProc) {
|
|
WNDPROC currentWndProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
if (currentWndProc == PluginWndProc)
|
|
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)mPluginWinProc);
|
|
mPluginWinProc = nullptr;
|
|
|
|
LONG_PTR style = GetWindowLongPtr(hWnd, GWL_STYLE);
|
|
style &= ~WS_CLIPCHILDREN;
|
|
SetWindowLongPtr(hWnd, GWL_STYLE, style);
|
|
}
|
|
|
|
if (mPluginType == nsPluginHost::eSpecialType_Flash && mParentWnd) {
|
|
::SetWindowLongPtr(mParentWnd, GWLP_WNDPROC, mParentProc);
|
|
mParentWnd = nullptr;
|
|
mParentProc = 0;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult PLUG_NewPluginNativeWindow(
|
|
nsPluginNativeWindow** aPluginNativeWindow) {
|
|
NS_ENSURE_ARG_POINTER(aPluginNativeWindow);
|
|
|
|
*aPluginNativeWindow = new nsPluginNativeWindowWin();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult PLUG_DeletePluginNativeWindow(
|
|
nsPluginNativeWindow* aPluginNativeWindow) {
|
|
NS_ENSURE_ARG_POINTER(aPluginNativeWindow);
|
|
nsPluginNativeWindowWin* p = (nsPluginNativeWindowWin*)aPluginNativeWindow;
|
|
delete p;
|
|
return NS_OK;
|
|
}
|