2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Andrei Volkov <av@netscape.com>
|
|
|
|
* Brian Stell <bstell@netscape.com>
|
|
|
|
* Peter Lubczynski <peterl@netscape.com>
|
2010-10-21 14:52:48 -07:00
|
|
|
* Jim Mathies <jmathies@mozilla.com>
|
2007-03-22 10:30:00 -07:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#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 "nsGUIEvent.h"
|
2010-10-21 14:52:48 -07:00
|
|
|
#include "nsWindowsDllInterceptor.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "nsPluginSafety.h"
|
|
|
|
#include "nsPluginNativeWindow.h"
|
|
|
|
#include "nsThreadUtils.h"
|
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
#include "nsTWeakRef.h"
|
2011-02-11 17:56:11 -08:00
|
|
|
#include "nsCrashOnException.h"
|
|
|
|
|
2009-09-16 18:30:26 -07:00
|
|
|
#define NP_POPUP_API_VERSION 16
|
|
|
|
|
|
|
|
#define nsMajorVersion(v) (((PRInt32)(v) >> 16) & 0xffff)
|
|
|
|
#define nsMinorVersion(v) ((PRInt32)(v) & 0xffff)
|
|
|
|
#define versionOK(suppliedV, requiredV) \
|
|
|
|
(nsMajorVersion(suppliedV) == nsMajorVersion(requiredV) \
|
|
|
|
&& nsMinorVersion(suppliedV) >= nsMinorVersion(requiredV))
|
|
|
|
|
|
|
|
|
2009-03-08 22:07:00 -07:00
|
|
|
#define NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION TEXT("MozillaPluginWindowPropertyAssociation")
|
2009-06-23 04:27:44 -07:00
|
|
|
#define NS_PLUGIN_CUSTOM_MSG_ID TEXT("MozFlashUserRelay")
|
|
|
|
#define WM_USER_FLASH WM_USER+1
|
|
|
|
static UINT sWM_FLASHBOUNCEMSG = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
typedef nsTWeakRef<class nsPluginNativeWindowWin> PluginWindowWeakRef;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* PLEvent handling code
|
|
|
|
*/
|
|
|
|
class PluginWindowEvent : public nsRunnable {
|
|
|
|
public:
|
|
|
|
PluginWindowEvent();
|
|
|
|
void Init(const PluginWindowWeakRef &ref, HWND hWnd, UINT msg, WPARAM wParam,
|
|
|
|
LPARAM lParam);
|
|
|
|
void Clear();
|
|
|
|
HWND GetWnd() { return mWnd; };
|
|
|
|
UINT GetMsg() { return mMsg; };
|
|
|
|
WPARAM GetWParam() { return mWParam; };
|
|
|
|
LPARAM GetLParam() { return mLParam; };
|
2007-06-15 09:23:45 -07:00
|
|
|
PRBool InUse() { return (mWnd!=NULL); };
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
|
|
|
|
protected:
|
|
|
|
PluginWindowWeakRef mPluginWindowRef;
|
|
|
|
HWND mWnd;
|
|
|
|
UINT mMsg;
|
|
|
|
WPARAM mWParam;
|
|
|
|
LPARAM mLParam;
|
|
|
|
};
|
|
|
|
|
|
|
|
PluginWindowEvent::PluginWindowEvent()
|
|
|
|
{
|
|
|
|
Clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
void PluginWindowEvent::Clear()
|
|
|
|
{
|
|
|
|
mWnd = NULL;
|
|
|
|
mMsg = 0;
|
|
|
|
mWParam = 0;
|
|
|
|
mLParam = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PluginWindowEvent::Init(const PluginWindowWeakRef &ref, HWND aWnd,
|
|
|
|
UINT aMsg, WPARAM aWParam, LPARAM aLParam)
|
|
|
|
{
|
2007-06-15 09:23:45 -07:00
|
|
|
NS_ASSERTION(aWnd != NULL, "invalid plugin event value");
|
|
|
|
NS_ASSERTION(mWnd == NULL, "event already in use");
|
2007-03-22 10:30:00 -07:00
|
|
|
mPluginWindowRef = ref;
|
|
|
|
mWnd = aWnd;
|
|
|
|
mMsg = aMsg;
|
|
|
|
mWParam = aWParam;
|
|
|
|
mLParam = aLParam;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nsPluginNativeWindow Windows specific class declaration
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
nsPluginType_Unknown = 0,
|
|
|
|
nsPluginType_Flash,
|
|
|
|
nsPluginType_Real,
|
2010-09-07 09:12:28 -07:00
|
|
|
nsPluginType_PDF,
|
2007-03-22 10:30:00 -07:00
|
|
|
nsPluginType_Other
|
|
|
|
} nsPluginType;
|
|
|
|
|
|
|
|
class nsPluginNativeWindowWin : public nsPluginNativeWindow {
|
|
|
|
public:
|
|
|
|
nsPluginNativeWindowWin();
|
|
|
|
virtual ~nsPluginNativeWindowWin();
|
|
|
|
|
2011-05-17 18:48:34 -07:00
|
|
|
virtual nsresult CallSetWindow(nsRefPtr<nsNPAPIPluginInstance> &aPluginInstance);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
private:
|
|
|
|
nsresult SubclassAndAssociateWindow();
|
|
|
|
nsresult UndoSubclassAndAssociateWindow();
|
|
|
|
|
|
|
|
public:
|
|
|
|
// locals
|
|
|
|
WNDPROC GetPrevWindowProc();
|
2010-10-21 14:52:48 -07:00
|
|
|
void SetPrevWindowProc(WNDPROC proc) { mPluginWinProc = proc; }
|
2007-03-22 10:30:00 -07:00
|
|
|
WNDPROC GetWindowProc();
|
2007-06-15 09:23:45 -07:00
|
|
|
PluginWindowEvent * GetPluginWindowEvent(HWND aWnd,
|
|
|
|
UINT aMsg,
|
|
|
|
WPARAM aWParam,
|
|
|
|
LPARAM aLParam);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
private:
|
|
|
|
WNDPROC mPluginWinProc;
|
2010-10-21 14:52:48 -07:00
|
|
|
WNDPROC mPrevWinProc;
|
2007-03-22 10:30:00 -07:00
|
|
|
PluginWindowWeakRef mWeakRef;
|
|
|
|
nsRefPtr<PluginWindowEvent> mCachedPluginWindowEvent;
|
|
|
|
|
2010-09-07 09:12:28 -07:00
|
|
|
HWND mParentWnd;
|
|
|
|
LONG_PTR mParentProc;
|
2007-03-22 10:30:00 -07:00
|
|
|
public:
|
|
|
|
nsPluginType mPluginType;
|
|
|
|
};
|
|
|
|
|
|
|
|
static PRBool sInMessageDispatch = PR_FALSE;
|
2010-10-21 14:52:48 -07:00
|
|
|
static PRBool sInPreviousMessageDispatch = PR_FALSE;
|
2007-03-22 10:30:00 -07:00
|
|
|
static UINT sLastMsg = 0;
|
|
|
|
|
2011-05-17 18:48:34 -07:00
|
|
|
static PRBool ProcessFlashMessageDelayed(nsPluginNativeWindowWin * aWin, nsNPAPIPluginInstance * aInst,
|
2007-03-22 10:30:00 -07:00
|
|
|
HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(aWin, NS_ERROR_NULL_POINTER);
|
2009-06-23 04:27:44 -07:00
|
|
|
NS_ENSURE_TRUE(aInst, NS_ERROR_NULL_POINTER);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-06-23 04:27:44 -07:00
|
|
|
if (msg == sWM_FLASHBOUNCEMSG) {
|
|
|
|
// See PluginWindowEvent::Run() below.
|
|
|
|
NS_ASSERTION((sWM_FLASHBOUNCEMSG != 0), "RegisterWindowMessage failed in flash plugin WM_USER message handling!");
|
|
|
|
NS_TRY_SAFE_CALL_VOID(::CallWindowProc((WNDPROC)aWin->GetWindowProc(), hWnd, WM_USER_FLASH, wParam, lParam),
|
2010-10-14 14:06:31 -07:00
|
|
|
aInst);
|
2009-06-23 04:27:44 -07:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (msg != WM_USER_FLASH)
|
2007-03-22 10:30:00 -07:00
|
|
|
return PR_FALSE; // no need to delay
|
|
|
|
|
|
|
|
// do stuff
|
|
|
|
nsCOMPtr<nsIRunnable> pwe = aWin->GetPluginWindowEvent(hWnd, msg, wParam, lParam);
|
|
|
|
if (pwe) {
|
|
|
|
NS_DispatchToCurrentThread(pwe);
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
class nsDelayedPopupsEnabledEvent : public nsRunnable
|
|
|
|
{
|
|
|
|
public:
|
2011-05-17 18:48:34 -07:00
|
|
|
nsDelayedPopupsEnabledEvent(nsNPAPIPluginInstance *inst)
|
2007-03-22 10:30:00 -07:00
|
|
|
: mInst(inst)
|
|
|
|
{}
|
|
|
|
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
|
|
|
|
|
|
private:
|
2011-05-17 18:48:34 -07:00
|
|
|
nsRefPtr<nsNPAPIPluginInstance> mInst;
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsDelayedPopupsEnabledEvent::Run()
|
|
|
|
{
|
|
|
|
mInst->PushPopupsEnabledState(PR_FALSE);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* New plugin window procedure
|
|
|
|
*/
|
2011-02-11 17:56:11 -08:00
|
|
|
static LRESULT CALLBACK PluginWndProcInternal(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
nsPluginNativeWindowWin * win = (nsPluginNativeWindowWin *)::GetProp(hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
|
|
if (!win)
|
|
|
|
return TRUE;
|
|
|
|
|
2007-03-24 02:45:51 -07:00
|
|
|
// The DispatchEvent(NS_PLUGIN_ACTIVATE) below can trigger a reentrant focus
|
|
|
|
// event which might destroy us. Hold a strong ref on the plugin instance
|
|
|
|
// to prevent that, bug 374229.
|
2011-05-17 18:48:34 -07:00
|
|
|
nsRefPtr<nsNPAPIPluginInstance> inst;
|
2007-03-24 02:45:51 -07:00
|
|
|
win->GetPluginInstance(inst);
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// Real may go into a state where it recursivly dispatches the same event
|
|
|
|
// when subclassed. If this is Real, lets examine the event and drop it
|
|
|
|
// on the floor if we get into this recursive situation. See bug 192914.
|
|
|
|
if (win->mPluginType == nsPluginType_Real) {
|
2010-10-21 14:52:48 -07:00
|
|
|
if (sInMessageDispatch && msg == sLastMsg)
|
|
|
|
return PR_TRUE;
|
|
|
|
// Cache the last message sent
|
|
|
|
sLastMsg = msg;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
PRBool enablePopups = PR_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(PR_TRUE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case WM_LBUTTONUP:
|
|
|
|
enablePopups = PR_TRUE;
|
|
|
|
|
|
|
|
// fall through
|
|
|
|
case WM_MBUTTONUP:
|
|
|
|
case WM_RBUTTONUP: {
|
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
|
|
win->GetPluginWidget(getter_AddRefs(widget));
|
|
|
|
if (widget)
|
|
|
|
widget->CaptureMouse(PR_FALSE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case WM_KEYDOWN:
|
|
|
|
// Ignore repeating keydown messages...
|
|
|
|
if ((lParam & 0x40000000) != 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// fall through
|
|
|
|
case WM_KEYUP:
|
|
|
|
enablePopups = PR_TRUE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_MOUSEACTIVATE: {
|
|
|
|
// If a child window of this plug-in is already focused,
|
2010-01-26 13:40:15 -08:00
|
|
|
// don't focus the parent to avoid focus dance. We'll
|
|
|
|
// receive a follow up WM_SETFOCUS which will notify
|
|
|
|
// the appropriate window anyway.
|
2007-03-22 10:30:00 -07:00
|
|
|
HWND focusedWnd = ::GetFocus();
|
|
|
|
if (!::IsChild((HWND)win->window, focusedWnd)) {
|
2010-01-26 13:40:15 -08:00
|
|
|
// 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.
|
2007-03-22 10:30:00 -07:00
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
|
|
win->GetPluginWidget(getter_AddRefs(widget));
|
|
|
|
if (widget) {
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
nsGUIEvent event(PR_TRUE, NS_PLUGIN_ACTIVATE, widget);
|
2007-03-22 10:30:00 -07:00
|
|
|
nsEventStatus status;
|
|
|
|
widget->DispatchEvent(&event, status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_SETFOCUS:
|
|
|
|
case WM_KILLFOCUS: {
|
2010-10-21 14:52:48 -07:00
|
|
|
// RealPlayer can crash, don't process the message for those,
|
|
|
|
// see bug 328675.
|
2008-02-26 20:35:20 -08:00
|
|
|
if (win->mPluginType == nsPluginType_Real && msg == sLastMsg)
|
|
|
|
return TRUE;
|
2010-10-21 14:52:48 -07:00
|
|
|
// 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.
|
2007-03-22 10:30:00 -07:00
|
|
|
WNDPROC prevWndProc = win->GetPrevWindowProc();
|
2010-10-21 14:52:48 -07:00
|
|
|
if (prevWndProc && !sInPreviousMessageDispatch) {
|
|
|
|
sInPreviousMessageDispatch = PR_TRUE;
|
2007-03-22 10:30:00 -07:00
|
|
|
::CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
|
2010-10-21 14:52:48 -07:00
|
|
|
sInPreviousMessageDispatch = PR_FALSE;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
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 == nsPluginType_Flash) {
|
2009-06-23 04:27:44 -07:00
|
|
|
if (ProcessFlashMessageDelayed(win, inst, hWnd, msg, wParam, lParam))
|
2007-03-22 10:30:00 -07:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2009-07-01 21:52:07 -07:00
|
|
|
if (enablePopups && inst) {
|
|
|
|
PRUint16 apiVersion;
|
|
|
|
if (NS_SUCCEEDED(inst->GetPluginAPIVersion(&apiVersion)) &&
|
2009-09-16 18:30:26 -07:00
|
|
|
!versionOK(apiVersion, NP_POPUP_API_VERSION)) {
|
2009-07-01 21:52:07 -07:00
|
|
|
inst->PushPopupsEnabledState(PR_TRUE);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sInMessageDispatch = PR_TRUE;
|
|
|
|
|
2009-07-01 21:52:07 -07:00
|
|
|
LRESULT res = TRUE;
|
2007-03-22 10:30:00 -07:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(res,
|
|
|
|
::CallWindowProc((WNDPROC)win->GetWindowProc(), hWnd, msg, wParam, lParam),
|
2010-10-14 14:06:31 -07:00
|
|
|
inst);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
sInMessageDispatch = PR_FALSE;
|
|
|
|
|
2009-07-01 21:52:07 -07:00
|
|
|
if (inst) {
|
2007-03-22 10:30:00 -07:00
|
|
|
// 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.
|
|
|
|
|
2009-07-01 21:52:07 -07:00
|
|
|
nsCOMPtr<nsIRunnable> event = new nsDelayedPopupsEnabledEvent(inst);
|
|
|
|
if (event)
|
2007-03-22 10:30:00 -07:00
|
|
|
NS_DispatchToCurrentThread(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-02-11 17:56:11 -08:00
|
|
|
static LRESULT CALLBACK PluginWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
|
|
{
|
|
|
|
return mozilla::CallWindowProcCrashProtected(PluginWndProcInternal, hWnd, msg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
/*
|
|
|
|
* 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 User32SetWindowLongPtrA sUser32SetWindowLongAHookStub = NULL;
|
|
|
|
static User32SetWindowLongPtrW sUser32SetWindowLongWHookStub = NULL;
|
|
|
|
#else
|
|
|
|
typedef LONG
|
|
|
|
(WINAPI *User32SetWindowLongA)(HWND hWnd,
|
|
|
|
int nIndex,
|
|
|
|
LONG dwNewLong);
|
|
|
|
typedef LONG
|
|
|
|
(WINAPI *User32SetWindowLongW)(HWND hWnd,
|
|
|
|
int nIndex,
|
|
|
|
LONG dwNewLong);
|
|
|
|
static User32SetWindowLongA sUser32SetWindowLongAHookStub = NULL;
|
|
|
|
static User32SetWindowLongW sUser32SetWindowLongWHookStub = NULL;
|
|
|
|
#endif
|
|
|
|
static inline PRBool
|
|
|
|
SetWindowLongHookCheck(HWND hWnd,
|
|
|
|
int nIndex,
|
|
|
|
LONG_PTR newLong)
|
|
|
|
{
|
|
|
|
nsPluginNativeWindowWin * win =
|
|
|
|
(nsPluginNativeWindowWin *)GetProp(hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
|
|
|
|
if (!win || (win && win->mPluginType != nsPluginType_Flash) ||
|
|
|
|
(nIndex == GWLP_WNDPROC &&
|
|
|
|
newLong == reinterpret_cast<LONG_PTR>(PluginWndProc)))
|
|
|
|
return PR_TRUE;
|
|
|
|
return PR_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>(sUser32SetWindowLongAHookStub(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()
|
|
|
|
{
|
|
|
|
#ifdef _WIN64
|
|
|
|
// XXX WindowsDllInterceptor doesn't support hooks
|
|
|
|
// in 64-bit builds, disabling this code for now.
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sUser32Intercept.Init("user32.dll");
|
|
|
|
#ifdef _WIN64
|
2011-05-02 05:34:14 -07:00
|
|
|
sUser32Intercept.AddHook("SetWindowLongPtrA", reinterpret_cast<intptr_t>(SetWindowLongPtrAHook),
|
2010-10-21 14:52:48 -07:00
|
|
|
(void**) &sUser32SetWindowLongAHookStub);
|
2011-05-02 05:34:14 -07:00
|
|
|
sUser32Intercept.AddHook("SetWindowLongPtrW", reinterpret_cast<intptr_t>(SetWindowLongPtrWHook),
|
2010-10-21 14:52:48 -07:00
|
|
|
(void**) &sUser32SetWindowLongWHookStub);
|
|
|
|
#else
|
2011-05-02 05:34:14 -07:00
|
|
|
sUser32Intercept.AddHook("SetWindowLongA", reinterpret_cast<intptr_t>(SetWindowLongAHook),
|
2010-10-21 14:52:48 -07:00
|
|
|
(void**) &sUser32SetWindowLongAHookStub);
|
2011-05-02 05:34:14 -07:00
|
|
|
sUser32Intercept.AddHook("SetWindowLongW", reinterpret_cast<intptr_t>(SetWindowLongWHook),
|
2010-10-21 14:52:48 -07:00
|
|
|
(void**) &sUser32SetWindowLongWHookStub);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/**
|
|
|
|
* nsPluginNativeWindowWin implementation
|
|
|
|
*/
|
|
|
|
nsPluginNativeWindowWin::nsPluginNativeWindowWin() : nsPluginNativeWindow()
|
|
|
|
{
|
|
|
|
// initialize the struct fields
|
|
|
|
window = nsnull;
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
width = 0;
|
|
|
|
height = 0;
|
|
|
|
|
|
|
|
mPrevWinProc = NULL;
|
|
|
|
mPluginWinProc = NULL;
|
|
|
|
mPluginType = nsPluginType_Unknown;
|
2010-09-07 09:12:28 -07:00
|
|
|
|
|
|
|
mParentWnd = NULL;
|
2010-11-06 07:25:34 -07:00
|
|
|
mParentProc = 0;
|
2010-09-07 09:12:28 -07:00
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
if (!sWM_FLASHBOUNCEMSG) {
|
2009-06-23 04:27:44 -07:00
|
|
|
sWM_FLASHBOUNCEMSG = ::RegisterWindowMessage(NS_PLUGIN_CUSTOM_MSG_ID);
|
2010-10-21 14:52:48 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginNativeWindowWin::~nsPluginNativeWindowWin()
|
|
|
|
{
|
|
|
|
// clear weak reference to self to prevent any pending events from
|
|
|
|
// dereferencing this.
|
|
|
|
mWeakRef.forget();
|
|
|
|
}
|
|
|
|
|
|
|
|
WNDPROC nsPluginNativeWindowWin::GetPrevWindowProc()
|
|
|
|
{
|
|
|
|
return mPrevWinProc;
|
|
|
|
}
|
|
|
|
|
|
|
|
WNDPROC nsPluginNativeWindowWin::GetWindowProc()
|
|
|
|
{
|
|
|
|
return mPluginWinProc;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP PluginWindowEvent::Run()
|
|
|
|
{
|
|
|
|
nsPluginNativeWindowWin *win = mPluginWindowRef.get();
|
|
|
|
if (!win)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
HWND hWnd = GetWnd();
|
|
|
|
if (!hWnd)
|
|
|
|
return NS_OK;
|
|
|
|
|
2011-05-17 18:48:34 -07:00
|
|
|
nsRefPtr<nsNPAPIPluginInstance> inst;
|
2007-03-22 10:30:00 -07:00
|
|
|
win->GetPluginInstance(inst);
|
2009-06-23 04:27:44 -07:00
|
|
|
|
|
|
|
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.
|
|
|
|
NS_TRY_SAFE_CALL_VOID(::CallWindowProc(win->GetWindowProc(),
|
|
|
|
hWnd,
|
|
|
|
GetMsg(),
|
|
|
|
GetWParam(),
|
|
|
|
GetLParam()),
|
2010-10-14 14:06:31 -07:00
|
|
|
inst);
|
2009-06-23 04:27:44 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
Clear();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-06-15 09:23:45 -07:00
|
|
|
PluginWindowEvent *
|
2007-03-22 10:30:00 -07:00
|
|
|
nsPluginNativeWindowWin::GetPluginWindowEvent(HWND aWnd, UINT aMsg, WPARAM aWParam, LPARAM aLParam)
|
|
|
|
{
|
|
|
|
if (!mWeakRef) {
|
|
|
|
mWeakRef = this;
|
|
|
|
if (!mWeakRef)
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
PluginWindowEvent *event;
|
2007-06-15 09:23:45 -07:00
|
|
|
|
|
|
|
// 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)
|
|
|
|
{
|
2007-03-22 10:30:00 -07:00
|
|
|
event = new PluginWindowEvent();
|
2007-06-15 09:23:45 -07:00
|
|
|
if (!event) return nsnull;
|
|
|
|
mCachedPluginWindowEvent = event;
|
|
|
|
}
|
|
|
|
else if (mCachedPluginWindowEvent->InUse())
|
|
|
|
{
|
|
|
|
event = new PluginWindowEvent();
|
|
|
|
if (!event) return nsnull;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2007-06-15 09:23:45 -07:00
|
|
|
else
|
|
|
|
{
|
2007-03-22 10:30:00 -07:00
|
|
|
event = mCachedPluginWindowEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
event->Init(mWeakRef, aWnd, aMsg, aWParam, aLParam);
|
|
|
|
return event;
|
|
|
|
}
|
|
|
|
|
2011-05-17 18:48:34 -07:00
|
|
|
nsresult nsPluginNativeWindowWin::CallSetWindow(nsRefPtr<nsNPAPIPluginInstance> &aPluginInstance)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-10-21 14:52:48 -07:00
|
|
|
// Note, 'window' can be null
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// 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
|
2010-10-21 14:52:48 -07:00
|
|
|
if (!aPluginInstance) {
|
|
|
|
UndoSubclassAndAssociateWindow();
|
|
|
|
nsPluginNativeWindow::CallSetWindow(aPluginInstance);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-09-07 09:12:28 -07:00
|
|
|
// check plugin mime type and cache it if it will need special treatment later
|
|
|
|
if (mPluginType == nsPluginType_Unknown) {
|
2010-10-21 14:52:48 -07:00
|
|
|
const char* mimetype = nsnull;
|
|
|
|
aPluginInstance->GetMIMEType(&mimetype);
|
|
|
|
if (mimetype) {
|
|
|
|
if (!strcmp(mimetype, "application/x-shockwave-flash"))
|
|
|
|
mPluginType = nsPluginType_Flash;
|
|
|
|
else if (!strcmp(mimetype, "audio/x-pn-realaudio-plugin"))
|
|
|
|
mPluginType = nsPluginType_Real;
|
|
|
|
else if (!strcmp(mimetype, "application/pdf"))
|
|
|
|
mPluginType = nsPluginType_PDF;
|
|
|
|
else
|
|
|
|
mPluginType = nsPluginType_Other;
|
2010-09-07 09:12:28 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
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;
|
|
|
|
|
|
|
|
// PDF plugin v7.0.9, v8.1.3, and v9.0 subclass parent window, bug 531551
|
|
|
|
// V8.2.2 and V9.1 don't have such problem.
|
|
|
|
if (mPluginType == nsPluginType_PDF) {
|
|
|
|
HWND parent = ::GetParent((HWND)window);
|
|
|
|
if (mParentWnd != parent) {
|
|
|
|
NS_ASSERTION(!mParentWnd, "Plugin's parent window changed");
|
|
|
|
mParentWnd = parent;
|
|
|
|
mParentProc = ::GetWindowLongPtr(mParentWnd, GWLP_WNDPROC);
|
|
|
|
}
|
2010-09-07 09:12:28 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginNativeWindow::CallSetWindow(aPluginInstance);
|
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
SubclassAndAssociateWindow();
|
2010-10-21 14:52:48 -07:00
|
|
|
|
|
|
|
if (window && mPluginType == nsPluginType_Flash &&
|
|
|
|
!GetPropW((HWND)window, L"PluginInstanceParentProperty")) {
|
|
|
|
HookSetWindowLongPtr();
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult nsPluginNativeWindowWin::SubclassAndAssociateWindow()
|
|
|
|
{
|
2010-10-21 14:52:48 -07:00
|
|
|
if (type != NPWindowTypeWindow || !window)
|
2007-03-22 10:30:00 -07:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
HWND hWnd = (HWND)window;
|
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
// check if we need to subclass
|
2009-01-13 10:15:39 -08:00
|
|
|
WNDPROC currentWndProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
2010-10-21 14:52:48 -07:00
|
|
|
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);
|
2007-03-22 10:30:00 -07:00
|
|
|
return NS_OK;
|
2010-10-21 14:52:48 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-07-11 21:49:12 -07:00
|
|
|
LONG_PTR style = GetWindowLongPtr(hWnd, GWL_STYLE);
|
2010-01-28 11:32:41 -08:00
|
|
|
// 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.
|
2010-01-28 12:23:07 -08:00
|
|
|
if (::GetPropW(hWnd, L"PluginInstanceParentProperty"))
|
|
|
|
style &= ~WS_CLIPCHILDREN;
|
|
|
|
else
|
|
|
|
style |= WS_CLIPCHILDREN;
|
2009-07-01 14:19:32 -07:00
|
|
|
SetWindowLongPtr(hWnd, GWL_STYLE, style);
|
|
|
|
|
2010-10-21 14:52:48 -07:00
|
|
|
mPluginWinProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)PluginWndProc);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!mPluginWinProc)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
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()
|
|
|
|
{
|
|
|
|
// release plugin instance
|
|
|
|
SetPluginInstance(nsnull);
|
|
|
|
|
|
|
|
// 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) {
|
2009-01-13 10:15:39 -08:00
|
|
|
WNDPROC currentWndProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (currentWndProc == PluginWndProc)
|
2010-10-21 14:52:48 -07:00
|
|
|
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)mPluginWinProc);
|
|
|
|
mPluginWinProc = NULL;
|
2009-07-01 14:19:32 -07:00
|
|
|
|
2010-07-11 21:49:12 -07:00
|
|
|
LONG_PTR style = GetWindowLongPtr(hWnd, GWL_STYLE);
|
2009-07-01 14:19:32 -07:00
|
|
|
style &= ~WS_CLIPCHILDREN;
|
|
|
|
SetWindowLongPtr(hWnd, GWL_STYLE, style);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-09-07 09:12:28 -07:00
|
|
|
if (mPluginType == nsPluginType_PDF && mParentWnd) {
|
|
|
|
::SetWindowLongPtr(mParentWnd, GWLP_WNDPROC, mParentProc);
|
|
|
|
mParentWnd = NULL;
|
2010-11-06 07:25:34 -07:00
|
|
|
mParentProc = 0;
|
2010-09-07 09:12:28 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult PLUG_NewPluginNativeWindow(nsPluginNativeWindow ** aPluginNativeWindow)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPluginNativeWindow);
|
|
|
|
|
|
|
|
*aPluginNativeWindow = new nsPluginNativeWindowWin();
|
|
|
|
|
|
|
|
return *aPluginNativeWindow ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult PLUG_DeletePluginNativeWindow(nsPluginNativeWindow * aPluginNativeWindow)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPluginNativeWindow);
|
|
|
|
nsPluginNativeWindowWin *p = (nsPluginNativeWindowWin *)aPluginNativeWindow;
|
|
|
|
delete p;
|
|
|
|
return NS_OK;
|
|
|
|
}
|