wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1072528. Part 1: Remove plugin-related code. r=bsmedberg

Browse Source
This commit is contained in:
Robert O'Callahan 2014-09-24 16:35:00 -04:00
parent 899afd7ff0
commit 51d7d48164
34 changed files with 36 additions and 1163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
dom/plugins/base/npapi.h
View File

@ -59,7 +59,7 @@
/*----------------------------------------------------------------------*/
#define NP_VERSION_MAJOR 0
#define NP_VERSION_MINOR 27
#define NP_VERSION_MINOR 28
/* The OS/2 version of Netscape uses RC_DATA to define the
@ -186,33 +186,6 @@ typedef enum {
NPFocusPrevious = 1
} NPFocusDirection;
/* These formats describe the format in the memory byte-order. This means if
* a 32-bit value of a pixel is viewed on a little-endian system the layout will
* be 0xAARRGGBB. The Alpha channel will be stored in the most significant
* bits. */
typedef enum {
/* 32-bit per pixel 8-bit per channel - premultiplied alpha */
NPImageFormatBGRA32 = 0x1,
/* 32-bit per pixel 8-bit per channel - 1 unused channel */
NPImageFormatBGRX32 = 0x2
} NPImageFormat;
typedef struct _NPAsyncSurface
{
uint32_t version;
NPSize size;
NPImageFormat format;
union {
struct {
uint32_t stride;
void *data;
} bitmap;
#if defined(XP_WIN)
HANDLE sharedHandle;
#endif
};
} NPAsyncSurface;
/* Return values for NPP_HandleEvent */
#define kNPEventNotHandled 0
#define kNPEventHandled 1
@ -259,24 +232,27 @@ typedef struct
#endif /* XP_UNIX */
typedef enum {
NPDrawingModelDUMMY
#if defined(XP_MACOSX)
#ifndef NP_NO_QUICKDRAW
NPDrawingModelQuickDraw = 0,
, NPDrawingModelQuickDraw = 0
#endif
NPDrawingModelCoreGraphics = 1,
NPDrawingModelOpenGL = 2,
NPDrawingModelCoreAnimation = 3,
NPDrawingModelInvalidatingCoreAnimation = 4,
, NPDrawingModelCoreGraphics = 1
, NPDrawingModelOpenGL = 2
, NPDrawingModelCoreAnimation = 3
, NPDrawingModelInvalidatingCoreAnimation = 4
#endif
#if defined(XP_WIN)
NPDrawingModelSyncWin = 5,
, NPDrawingModelSyncWin = 5
#endif
#if defined(MOZ_X11)
NPDrawingModelSyncX = 6,
, NPDrawingModelSyncX = 6
#endif
NPDrawingModelAsyncBitmapSurface = 7
#if 0 /* OBSOLETE */
, NPDrawingModelAsyncBitmapSurfaceOBSOLETE = 7
#if defined(XP_WIN)
, NPDrawingModelAsyncWindowsDXGISurface = 8
, NPDrawingModelAsyncWindowsDXGISurfaceOBSOLETE = 8
#endif
#endif
} NPDrawingModel;
@ -420,9 +396,11 @@ typedef enum {
, NPNVsupportsCoreAnimationBool = 2003
, NPNVsupportsInvalidatingCoreAnimationBool = 2004
#endif
, NPNVsupportsAsyncBitmapSurfaceBool = 2007
#if 0 /* OBSOLETE */
, NPNVsupportsAsyncBitmapSurfaceBoolOBSOLETE = 2007
#if defined(XP_WIN)
, NPNVsupportsAsyncWindowsDXGISurfaceBool = 2008
, NPNVsupportsAsyncWindowsDXGISurfaceBoolOBSOLETE = 2008
#endif
#endif
#if defined(XP_MACOSX)
#ifndef NP_NO_CARBON
@ -867,11 +845,6 @@ NPBool NPN_ConvertPoint(NPP instance, double sourceX, double sourceY, NPCoo
NPBool NPN_HandleEvent(NPP instance, void *event, NPBool handled);
NPBool NPN_UnfocusInstance(NPP instance, NPFocusDirection direction);
void NPN_URLRedirectResponse(NPP instance, void* notifyData, NPBool allow);
NPError NPN_InitAsyncSurface(NPP instance, NPSize *size,
NPImageFormat format, void *initData,
NPAsyncSurface *surface);
NPError NPN_FinalizeAsyncSurface(NPP instance, NPAsyncSurface *surface);
void NPN_SetCurrentAsyncSurface(NPP instance, NPAsyncSurface *surface, NPRect *changed);
#ifdef __cplusplus
} /* end extern "C" */

11
dom/plugins/base/npfunctions.h
View File

@ -92,9 +92,8 @@ typedef NPBool (*NPN_ConvertPointPtr)(NPP instance, double sourceX, double
typedef NPBool (*NPN_HandleEventPtr)(NPP instance, void *event, NPBool handled);
typedef NPBool (*NPN_UnfocusInstancePtr)(NPP instance, NPFocusDirection direction);
typedef void (*NPN_URLRedirectResponsePtr)(NPP instance, void* notifyData, NPBool allow);
typedef NPError (*NPN_InitAsyncSurfacePtr)(NPP instance, NPSize *size, NPImageFormat format, void *initData, NPAsyncSurface *surface);
typedef NPError (*NPN_FinalizeAsyncSurfacePtr)(NPP instance, NPAsyncSurface *surface);
typedef void (*NPN_SetCurrentAsyncSurfacePtr)(NPP instance, NPAsyncSurface *surface, NPRect *changed);
typedef void (*NPN_DummyPtr)(void);
typedef struct _NPPluginFuncs {
uint16_t size;
@ -179,9 +178,9 @@ typedef struct _NPNetscapeFuncs {
NPN_HandleEventPtr handleevent;
NPN_UnfocusInstancePtr unfocusinstance;
NPN_URLRedirectResponsePtr urlredirectresponse;
NPN_InitAsyncSurfacePtr initasyncsurface;
NPN_FinalizeAsyncSurfacePtr finalizeasyncsurface;
NPN_SetCurrentAsyncSurfacePtr setcurrentasyncsurface;
NPN_DummyPtr initasyncsurfaceOBSOLETE;
NPN_DummyPtr finalizeasyncsurfaceOBSOLETE;
NPN_DummyPtr setcurrentasyncsurfaceOBSOLETE;
} NPNetscapeFuncs;
#ifdef XP_MACOSX

6
dom/plugins/base/nsIPluginInstanceOwner.idl
View File

@ -26,7 +26,7 @@ enum nsPluginTagType {
// Do not make this interface scriptable, because the virtual functions in C++
// blocks will make script call the wrong functions.
[uuid(59BE4CA5-3CB0-40E6-A111-9A88C8477610)]
[uuid(c4e26e5d-7a9b-4900-b567-e128c4be6e31)]
interface nsIPluginInstanceOwner : nsISupports
{
/**
@ -110,10 +110,6 @@ interface nsIPluginInstanceOwner : nsISupports
virtual NPError ShowNativeContextMenu(NPMenu* menu, void* event) = 0;
virtual NPBool ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
double *destX, double *destY, NPCoordinateSpace destSpace) = 0;
virtual NPError InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface) = 0;
virtual NPError FinalizeAsyncSurface(NPAsyncSurface *surface) = 0;
virtual void SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed) = 0;
%}
void setEventModel(in int32_t eventModel);

35
dom/plugins/base/nsNPAPIPlugin.cpp
View File

@ -164,10 +164,7 @@ static NPNetscapeFuncs sBrowserFuncs = {
_convertpoint,
nullptr, // handleevent, unimplemented
nullptr, // unfocusinstance, unimplemented
_urlredirectresponse,
_initasyncsurface,
_finalizeasyncsurface,
_setcurrentasyncsurface
_urlredirectresponse
};
static Mutex *sPluginThreadAsyncCallLock = nullptr;
@ -2777,36 +2774,6 @@ _popupcontextmenu(NPP instance, NPMenu* menu)
return inst->PopUpContextMenu(menu);
}
NPError
_initasyncsurface(NPP instance, NPSize *size, NPImageFormat format, void *initData, NPAsyncSurface *surface)
{
nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
if (!inst)
return NPERR_GENERIC_ERROR;
return inst->InitAsyncSurface(size, format, initData, surface);
}
NPError
_finalizeasyncsurface(NPP instance, NPAsyncSurface *surface)
{
nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
if (!inst)
return NPERR_GENERIC_ERROR;
return inst->FinalizeAsyncSurface(surface);
}
void
_setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
{
nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
if (!inst)
return;
inst->SetCurrentAsyncSurface(surface, changed);
}
NPBool
_convertpoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace)
{

9
dom/plugins/base/nsNPAPIPlugin.h
View File

@ -247,15 +247,6 @@ _unscheduletimer(NPP instance, uint32_t timerID);
NPError
_popupcontextmenu(NPP instance, NPMenu* menu);
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);
NPBool
_convertpoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace);

26
dom/plugins/base/nsNPAPIPluginInstance.cpp
View File

@ -1647,32 +1647,6 @@ nsNPAPIPluginInstance::URLRedirectResponse(void* notifyData, NPBool allow)
}
}
NPError
nsNPAPIPluginInstance::InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface)
{
if (mOwner)
return mOwner->InitAsyncSurface(size, format, initData, surface);
return NPERR_GENERIC_ERROR;
}
NPError
nsNPAPIPluginInstance::FinalizeAsyncSurface(NPAsyncSurface *surface)
{
if (mOwner)
return mOwner->FinalizeAsyncSurface(surface);
return NPERR_GENERIC_ERROR;
}
void
nsNPAPIPluginInstance::SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed)
{
if (mOwner)
mOwner->SetCurrentAsyncSurface(surface, changed);
}
class CarbonEventModelFailureEvent : public nsRunnable {
public:
nsCOMPtr<nsIContent> mContent;

5
dom/plugins/base/nsNPAPIPluginInstance.h
View File

@ -274,11 +274,6 @@ public:
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();

15
dom/plugins/base/nsPluginInstanceOwner.cpp
View File

@ -759,21 +759,6 @@ NPBool nsPluginInstanceOwner::ConvertPoint(double sourceX, double sourceY, NPCoo
#endif
}
NPError nsPluginInstanceOwner::InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface)
{
return NPERR_INCOMPATIBLE_VERSION_ERROR;
}
NPError nsPluginInstanceOwner::FinalizeAsyncSurface(NPAsyncSurface *)
{
return NPERR_INCOMPATIBLE_VERSION_ERROR;
}
void nsPluginInstanceOwner::SetCurrentAsyncSurface(NPAsyncSurface *, NPRect*)
{
}
NS_IMETHODIMP nsPluginInstanceOwner::GetTagType(nsPluginTagType *result)
{
NS_ENSURE_ARG_POINTER(result);

5
dom/plugins/base/nsPluginInstanceOwner.h
View File

@ -67,11 +67,6 @@ public:
NPBool ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
double *destX, double *destY, NPCoordinateSpace destSpace) MOZ_OVERRIDE;
virtual NPError InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface) MOZ_OVERRIDE;
virtual NPError FinalizeAsyncSurface(NPAsyncSurface *surface) MOZ_OVERRIDE;
virtual void SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed) MOZ_OVERRIDE;
/**
* Get the type of the HTML tag that was used ot instantiate this
* plugin. Currently supported tags are EMBED, OBJECT and APPLET.

28
dom/plugins/ipc/PPluginInstance.ipdl
View File

@ -17,7 +17,6 @@ using NPError from "npapi.h";
using struct mozilla::plugins::NPRemoteWindow from "mozilla/plugins/PluginMessageUtils.h";
using struct mozilla::plugins::NPRemoteEvent from "mozilla/plugins/PluginMessageUtils.h";
using NPRect from "npapi.h";
using NPImageFormat from "npapi.h";
using NPNURLVariable from "npapi.h";
using NPCoordinateSpace from "npapi.h";
using NPNVariable from "npapi.h";
@ -26,9 +25,7 @@ using gfxSurfaceType from "gfxTypes.h";
using gfxIntSize from "nsSize.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
using mozilla::plugins::WindowsSharedMemoryHandle from "mozilla/plugins/PluginMessageUtils.h";
using mozilla::plugins::DXGISharedSurfaceHandle from "mozilla/plugins/PluginMessageUtils.h";
using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
using struct SurfaceDescriptorX11 from "gfxipc/ShadowLayerUtils.h";
using mozilla::layers::SurfaceDescriptorX11 from "gfxipc/ShadowLayerUtils.h";
using struct nsIntRect from "nsRect.h";
namespace mozilla {
@ -57,21 +54,6 @@ union OptionalShmem {
null_t;
};
union AsyncSurfaceDescriptor {
Shmem;
DXGISharedSurfaceHandle;
};
struct NPRemoteAsyncSurface
{
uint32_t version;
gfxIntSize size;
NPImageFormat format;
uint32_t stride;
AsyncSurfaceDescriptor data;
uintptr_t hostPtr;
};
intr protocol PPluginInstance
{
manager PPluginModule;
@ -162,7 +144,7 @@ parent:
intr NPN_SetValue_NPPVpluginUsesDOMForCursor(bool useDOMForCursor)
returns (NPError result);
intr NPN_SetValue_NPPVpluginDrawingModel(int drawingModel)
returns (OptionalShmem remoteImageData, CrossProcessMutexHandle mutex, NPError result);
returns (NPError result);
intr NPN_SetValue_NPPVpluginEventModel(int eventModel)
returns (NPError result);
@ -220,17 +202,11 @@ parent:
async RedrawPlugin();
intr NPN_InitAsyncSurface(gfxIntSize size, NPImageFormat format)
returns (NPRemoteAsyncSurface surfData, bool result);
// Send notification that a plugin tried to negotiate Carbon NPAPI so that
// users can be notified that restarting the browser in i386 mode may allow
// them to use the plugin.
sync NegotiatedCarbon();
// Notifies us we can release a Async Surface DXGI texture.
async ReleaseDXGISharedSurface(DXGISharedSurfaceHandle handle);
both:
async PPluginScriptableObject();

2
dom/plugins/ipc/PPluginModule.ipdl
View File

@ -49,7 +49,7 @@ child:
intr NP_GetEntryPoints()
returns (NPError rv);
intr NP_Initialize(uint32_t aFlags)
intr NP_Initialize()
returns (NPError rv);
intr PPluginInstance(nsCString aMimeType,

258
dom/plugins/ipc/PluginInstanceChild.cpp
View File

@ -125,7 +125,6 @@ PluginInstanceChild::PluginInstanceChild(const NPPluginFuncs* aPluginIface)
, mContentsScaleFactor(1.0)
#endif
, mDrawingModel(kDefaultDrawingModel)
, mCurrentAsyncSurface(0)
, mAsyncInvalidateMutex("PluginInstanceChild::mAsyncInvalidateMutex")
, mAsyncInvalidateTask(0)
, mCachedWindowActor(nullptr)
@ -381,25 +380,6 @@ PluginInstanceChild::NPN_GetValue(NPNVariable aVar,
#endif
}
case NPNVsupportsAsyncBitmapSurfaceBool: {
#ifdef XP_WIN
*((NPBool*)aValue) = PluginModuleChild::current()->AsyncDrawingAllowed();
#else
// We do not support non-windows yet.
*((NPBool*)aValue) = false;
#endif
return NPERR_NO_ERROR;
}
#ifdef XP_WIN
case NPNVsupportsAsyncWindowsDXGISurfaceBool: {
bool val;
CallNPN_GetValue_DrawingModelSupport(NPNVsupportsAsyncWindowsDXGISurfaceBool, &val);
*((NPBool*)aValue) = val;
return NPERR_NO_ERROR;
}
#endif
#ifdef XP_MACOSX
case NPNVsupportsCoreGraphicsBool: {
*((NPBool*)aValue) = true;
@ -543,24 +523,9 @@ PluginInstanceChild::NPN_SetValue(NPPVariable aVar, void* aValue)
NPError rv;
int drawingModel = (int16_t) (intptr_t) aValue;
if (!PluginModuleChild::current()->AsyncDrawingAllowed() &&
IsDrawingModelAsync(drawingModel)) {
return NPERR_GENERIC_ERROR;
}
CrossProcessMutexHandle handle;
OptionalShmem optionalShmem;
if (!CallNPN_SetValue_NPPVpluginDrawingModel(drawingModel, &optionalShmem, &handle, &rv))
if (!CallNPN_SetValue_NPPVpluginDrawingModel(drawingModel, &rv))
return NPERR_GENERIC_ERROR;
if (IsDrawingModelAsync(drawingModel)) {
if (optionalShmem.type() != OptionalShmem::TShmem) {
return NPERR_GENERIC_ERROR;
}
mRemoteImageDataShmem = optionalShmem.get_Shmem();
mRemoteImageData = mRemoteImageDataShmem.get<RemoteImageData>();
mRemoteImageDataMutex = new CrossProcessMutex(handle);
}
mDrawingModel = drawingModel;
#ifdef XP_MACOSX
@ -2485,212 +2450,6 @@ PluginInstanceChild::NPN_URLRedirectResponse(void* notifyData, NPBool allow)
NS_ASSERTION(false, "Couldn't find stream for redirect response!");
}
NPError
PluginInstanceChild::DeallocateAsyncBitmapSurface(NPAsyncSurface *aSurface)
{
AsyncBitmapData* data;
if (!mAsyncBitmaps.Get(aSurface, &data)) {
return NPERR_INVALID_PARAM;
}
DeallocShmem(data->mShmem);
aSurface->bitmap.data = nullptr;
mAsyncBitmaps.Remove(aSurface);
return NPERR_NO_ERROR;
}
bool
PluginInstanceChild::IsAsyncDrawing()
{
return IsDrawingModelAsync(mDrawingModel);
}
NPError
PluginInstanceChild::NPN_InitAsyncSurface(NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface)
{
AssertPluginThread();
surface->bitmap.data = nullptr;
if (!IsAsyncDrawing()) {
return NPERR_GENERIC_ERROR;
}
switch (mDrawingModel) {
case NPDrawingModelAsyncBitmapSurface: {
if (mAsyncBitmaps.Get(surface, nullptr)) {
return NPERR_INVALID_PARAM;
}
if (size->width < 0 || size->height < 0) {
return NPERR_INVALID_PARAM;
}
bool result;
NPRemoteAsyncSurface remote;
if (!CallNPN_InitAsyncSurface(gfxIntSize(size->width, size->height), format, &remote, &result) || !result) {
return NPERR_OUT_OF_MEMORY_ERROR;
}
NS_ABORT_IF_FALSE(remote.data().get_Shmem().IsWritable(),
"Failed to create writable shared memory.");
AsyncBitmapData *data = new AsyncBitmapData;
mAsyncBitmaps.Put(surface, data);
data->mRemotePtr = (void*)remote.hostPtr();
data->mShmem = remote.data().get_Shmem();
surface->bitmap.data = data->mShmem.get<unsigned char>();
surface->bitmap.stride = remote.stride();
surface->format = remote.format();
surface->size.width = remote.size().width;
surface->size.height = remote.size().height;
return NPERR_NO_ERROR;
}
#ifdef XP_WIN
case NPDrawingModelAsyncWindowsDXGISurface: {
if (size->width < 0 || size->height < 0) {
return NPERR_INVALID_PARAM;
}
bool result;
NPRemoteAsyncSurface remote;
if (!CallNPN_InitAsyncSurface(gfxIntSize(size->width, size->height), format, &remote, &result) || !result) {
return NPERR_OUT_OF_MEMORY_ERROR;
}
surface->format = remote.format();
surface->size.width = remote.size().width;
surface->size.height = remote.size().height;
surface->sharedHandle = remote.data().get_DXGISharedSurfaceHandle();
return NPERR_NO_ERROR;
}
#endif
}
return NPERR_GENERIC_ERROR;
}
NPError
PluginInstanceChild::NPN_FinalizeAsyncSurface(NPAsyncSurface *surface)
{
AssertPluginThread();
if (!IsAsyncDrawing()) {
return NPERR_GENERIC_ERROR;
}
switch (mDrawingModel) {
case NPDrawingModelAsyncBitmapSurface: {
AsyncBitmapData *bitmapData;
if (!mAsyncBitmaps.Get(surface, &bitmapData)) {
return NPERR_GENERIC_ERROR;
}
{
CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
RemoteImageData *data = mRemoteImageData;
if (data->mBitmap.mData == bitmapData->mRemotePtr) {
data->mBitmap.mData = nullptr;
data->mSize = IntSize(0, 0);
data->mWasUpdated = true;
}
}
return DeallocateAsyncBitmapSurface(surface);
}
#ifdef XP_WIN
case NPDrawingModelAsyncWindowsDXGISurface: {
{
CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
RemoteImageData *data = mRemoteImageData;
if (data->mTextureHandle == surface->sharedHandle) {
data->mTextureHandle = nullptr;
data->mSize = IntSize(0, 0);
data->mWasUpdated = true;
}
}
SendReleaseDXGISharedSurface(surface->sharedHandle);
return NPERR_NO_ERROR;
}
#endif
}
return NPERR_GENERIC_ERROR;
}
void
PluginInstanceChild::NPN_SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed)
{
if (!IsAsyncDrawing()) {
return;
}
RemoteImageData *data = mRemoteImageData;
if (!surface) {
CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
data->mBitmap.mData = nullptr;
data->mSize = IntSize(0, 0);
data->mWasUpdated = true;
} else {
switch (mDrawingModel) {
case NPDrawingModelAsyncBitmapSurface:
{
AsyncBitmapData *bitmapData;
if (!mAsyncBitmaps.Get(surface, &bitmapData)) {
return;
}
CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
data->mBitmap.mData = (unsigned char*)bitmapData->mRemotePtr;
data->mSize = IntSize(surface->size.width, surface->size.height);
data->mFormat = surface->format == NPImageFormatBGRX32 ?
RemoteImageData::BGRX32 : RemoteImageData::BGRA32;
data->mBitmap.mStride = surface->bitmap.stride;
data->mWasUpdated = true;
break;
}
#ifdef XP_WIN
case NPDrawingModelAsyncWindowsDXGISurface:
{
CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
data->mType = RemoteImageData::DXGI_TEXTURE_HANDLE;
data->mSize = IntSize(surface->size.width, surface->size.height);
data->mFormat = surface->format == NPImageFormatBGRX32 ?
RemoteImageData::BGRX32 : RemoteImageData::BGRA32;
data->mTextureHandle = surface->sharedHandle;
data->mWasUpdated = true;
break;
}
#endif
}
}
{
MutexAutoLock autoLock(mAsyncInvalidateMutex);
if (!mAsyncInvalidateTask) {
mAsyncInvalidateTask =
NewRunnableMethod<PluginInstanceChild, void (PluginInstanceChild::*)()>
(this, &PluginInstanceChild::DoAsyncRedraw);
ProcessChild::message_loop()->PostTask(FROM_HERE, mAsyncInvalidateTask);
}
}
}
void
PluginInstanceChild::DoAsyncRedraw()
{
@ -3919,16 +3678,6 @@ PluginInstanceChild::ClearAllSurfaces()
#endif
}
PLDHashOperator
PluginInstanceChild::DeleteSurface(NPAsyncSurface* surf, nsAutoPtr<AsyncBitmapData> &data, void* userArg)
{
PluginInstanceChild *inst = static_cast<PluginInstanceChild*>(userArg);
inst->DeallocShmem(data->mShmem);
return PL_DHASH_REMOVE;
}
bool
PluginInstanceChild::AnswerNPP_Destroy(NPError* aResult)
{
@ -4004,11 +3753,6 @@ PluginInstanceChild::AnswerNPP_Destroy(NPError* aResult)
mPendingAsyncCalls.Clear();
if (mAsyncBitmaps.Count()) {
NS_ERROR("Not all AsyncBitmaps were finalized by a plugin!");
mAsyncBitmaps.Enumerate(DeleteSurface, this);
}
#ifdef MOZ_WIDGET_GTK
if (mWindow.type == NPWindowTypeWindow && !mXEmbed) {
xt_client_xloop_destroy();

18
dom/plugins/ipc/PluginInstanceChild.h
View File

@ -240,12 +240,6 @@ public:
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();
private:
friend class PluginModuleChild;
@ -256,8 +250,6 @@ private:
bool IsAsyncDrawing();
NPError DeallocateAsyncBitmapSurface(NPAsyncSurface *aSurface);
virtual bool RecvUpdateBackground(const SurfaceDescriptor& aBackground,
const nsIntRect& aRect) MOZ_OVERRIDE;
@ -365,17 +357,7 @@ private:
double mContentsScaleFactor;
#endif
int16_t mDrawingModel;
NPAsyncSurface* mCurrentAsyncSurface;
struct AsyncBitmapData {
void *mRemotePtr;
Shmem mShmem;
};
static PLDHashOperator DeleteSurface(NPAsyncSurface* surf, nsAutoPtr<AsyncBitmapData> &data, void* userArg);
nsClassHashtable<nsPtrHashKey<NPAsyncSurface>, AsyncBitmapData> mAsyncBitmaps;
Shmem mRemoteImageDataShmem;
mozilla::layers::RemoteImageData *mRemoteImageData;
nsAutoPtr<CrossProcessMutex> mRemoteImageDataMutex;
mozilla::Mutex mAsyncInvalidateMutex;
CancelableTask *mAsyncInvalidateTask;

169
dom/plugins/ipc/PluginInstanceParent.cpp
View File

@ -108,13 +108,6 @@ PluginInstanceParent::~PluginInstanceParent()
if (mShColorSpace)
::CGColorSpaceRelease(mShColorSpace);
#endif
if (mRemoteImageDataShmem.IsWritable()) {
if (mImageContainer) {
mImageContainer->SetRemoteImageData(nullptr, nullptr);
mImageContainer->SetCompositionNotifySink(nullptr);
}
DeallocShmem(mRemoteImageDataShmem);
}
}
bool
@ -253,12 +246,6 @@ PluginInstanceParent::InternalGetValueForNPObject(
return true;
}
bool
PluginInstanceParent::IsAsyncDrawing()
{
return IsDrawingModelAsync(mDrawingModel);
}
bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVWindowNPObject(
PPluginScriptableObjectParent** aValue,
@ -290,17 +277,6 @@ bool
PluginInstanceParent::AnswerNPN_GetValue_DrawingModelSupport(const NPNVariable& model, bool* value)
{
*value = false;
#ifdef XP_WIN
switch (model) {
case NPNVsupportsAsyncWindowsDXGISurfaceBool: {
if (gfxWindowsPlatform::GetPlatform()->GetRenderMode() == gfxWindowsPlatform::RENDER_DIRECT2D) {
*value = true;
}
}
}
#endif
return true;
}
@ -359,10 +335,8 @@ private:
bool
PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(
const int& drawingModel, OptionalShmem *shmem, CrossProcessMutexHandle *mutex, NPError* result)
const int& drawingModel, NPError* result)
{
*shmem = null_t();
#ifdef XP_MACOSX
if (drawingModel == NPDrawingModelCoreAnimation ||
drawingModel == NPDrawingModelInvalidatingCoreAnimation) {
@ -374,47 +348,7 @@ PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(
(void*)NPDrawingModelCoreGraphics);
} else
#endif
if (drawingModel == NPDrawingModelAsyncBitmapSurface
#ifdef XP_WIN
|| drawingModel == NPDrawingModelAsyncWindowsDXGISurface
#endif
) {
ImageContainer *container = GetImageContainer();
if (!container) {
*result = NPERR_GENERIC_ERROR;
return true;
}
#ifdef XP_WIN
if (drawingModel == NPDrawingModelAsyncWindowsDXGISurface &&
gfxWindowsPlatform::GetPlatform()->GetRenderMode() != gfxWindowsPlatform::RENDER_DIRECT2D) {
*result = NPERR_GENERIC_ERROR;
return true;
}
#endif
mDrawingModel = drawingModel;
*result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,
reinterpret_cast<void*>(static_cast<uintptr_t>(drawingModel)));
if (*result != NPERR_NO_ERROR) {
return true;
}
AllocUnsafeShmem(sizeof(RemoteImageData), SharedMemory::TYPE_BASIC, &mRemoteImageDataShmem);
*shmem = mRemoteImageDataShmem;
mRemoteImageDataMutex = new CrossProcessMutex("PluginInstanceParent.mRemoteImageDataMutex");
*mutex = mRemoteImageDataMutex->ShareToProcess(OtherProcess());
container->SetRemoteImageData(mRemoteImageDataShmem.get<RemoteImageData>(), mRemoteImageDataMutex);
mNotifySink = new NotificationSink(this);
container->SetCompositionNotifySink(mNotifySink);
} else if (
if (
#if defined(XP_WIN)
drawingModel == NPDrawingModelSyncWin
#elif defined(XP_MACOSX)
@ -426,20 +360,9 @@ PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(
false
#endif
) {
*shmem = null_t();
mDrawingModel = drawingModel;
*result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,
(void*)(intptr_t)drawingModel);
if (mRemoteImageDataShmem.IsWritable()) {
if (mImageContainer) {
mImageContainer->SetRemoteImageData(nullptr, nullptr);
mImageContainer->SetCompositionNotifySink(nullptr);
}
DeallocShmem(mRemoteImageDataShmem);
mRemoteImageDataMutex = nullptr;
}
} else {
*result = NPERR_GENERIC_ERROR;
}
@ -716,12 +639,6 @@ PluginInstanceParent::GetImageContainer(ImageContainer** aContainer)
return NS_ERROR_FAILURE;
}
if (IsAsyncDrawing()) {
NS_IF_ADDREF(container);
*aContainer = container;
return NS_OK;
}
#ifdef XP_MACOSX
if (ioSurface) {
nsRefPtr<Image> image = container->CreateImage(ImageFormat::MAC_IOSURFACE);
@ -1187,12 +1104,6 @@ PluginInstanceParent::NPP_HandleEvent(void* event)
#if defined(OS_WIN)
if (mWindowType == NPWindowTypeDrawable) {
if (IsAsyncDrawing()) {
if (npevent->event == WM_PAINT || npevent->event == DoublePassRenderingEvent()) {
// This plugin maintains its own async drawing.
return handled;
}
}
if (DoublePassRenderingEvent() == npevent->event) {
return CallPaint(npremoteevent, &handled) && handled;
}
@ -1691,73 +1602,6 @@ PluginInstanceParent::AnswerNPN_ConvertPoint(const double& sourceX,
return true;
}
bool
PluginInstanceParent::AnswerNPN_InitAsyncSurface(const gfxIntSize& size,
const NPImageFormat& format,
NPRemoteAsyncSurface* surfData,
bool* result)
{
if (!IsAsyncDrawing()) {
*result = false;
return true;
}
switch (mDrawingModel) {
case NPDrawingModelAsyncBitmapSurface: {
Shmem sharedMem;
if (!AllocUnsafeShmem(size.width * size.height * 4, SharedMemory::TYPE_BASIC, &sharedMem)) {
*result = false;
return true;
}
surfData->size() = size;
surfData->hostPtr() = (uintptr_t)sharedMem.get<unsigned char>();
surfData->stride() = size.width * 4;
surfData->format() = format;
surfData->data() = sharedMem;
*result = true;
return true;
}
#ifdef XP_WIN
case NPDrawingModelAsyncWindowsDXGISurface: {
ID3D10Device1 *device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();
nsRefPtr<ID3D10Texture2D> texture;
CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, size.width, size.height, 1, 1);
desc.MiscFlags = D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;
desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
if (FAILED(device->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture)))) {
*result = false;
return true;
}
nsRefPtr<IDXGIResource> resource;
if (FAILED(texture->QueryInterface(IID_IDXGIResource, getter_AddRefs(resource)))) {
*result = false;
return true;
}
HANDLE sharedHandle;
if (FAILED(resource->GetSharedHandle(&sharedHandle))) {
*result = false;
return true;
}
surfData->size() = size;
surfData->data() = sharedHandle;
surfData->format() = format;
mTextureMap.Put(sharedHandle, texture);
*result = true;
}
#endif
}
return true;
}
bool
PluginInstanceParent::RecvRedrawPlugin()
{
@ -1781,15 +1625,6 @@ PluginInstanceParent::RecvNegotiatedCarbon()
return true;
}
bool
PluginInstanceParent::RecvReleaseDXGISharedSurface(const DXGISharedSurfaceHandle &aHandle)
{
#ifdef XP_WIN
mTextureMap.Remove(aHandle);
#endif
return true;
}
#if defined(OS_WIN)
/*

14
dom/plugins/ipc/PluginInstanceParent.h
View File

@ -119,8 +119,6 @@ public:
NPError* result) MOZ_OVERRIDE;
virtual bool
AnswerNPN_SetValue_NPPVpluginDrawingModel(const int& drawingModel,
OptionalShmem *remoteImageData,
CrossProcessMutexHandle *mutex,
NPError* result) MOZ_OVERRIDE;
virtual bool
AnswerNPN_SetValue_NPPVpluginEventModel(const int& eventModel,
@ -206,20 +204,12 @@ public:
double *destY,
bool *result) MOZ_OVERRIDE;
virtual bool
AnswerNPN_InitAsyncSurface(const gfxIntSize& size,
const NPImageFormat& format,
NPRemoteAsyncSurface* surfData,
bool* result) MOZ_OVERRIDE;
virtual bool
RecvRedrawPlugin() MOZ_OVERRIDE;
virtual bool
RecvNegotiatedCarbon() MOZ_OVERRIDE;
virtual bool RecvReleaseDXGISharedSurface(const DXGISharedSurfaceHandle &aHandle) MOZ_OVERRIDE;
NPError NPP_SetWindow(const NPWindow* aWindow);
NPError NPP_GetValue(NPPVariable variable, void* retval);
@ -301,15 +291,11 @@ private:
PPluginScriptableObjectParent** aValue,
NPError* aResult);
bool IsAsyncDrawing();
private:
PluginModuleParent* mParent;
NPP mNPP;
const NPNetscapeFuncs* mNPNIface;
NPWindowType mWindowType;
Shmem mRemoteImageDataShmem;
nsAutoPtr<CrossProcessMutex> mRemoteImageDataMutex;
int16_t mDrawingModel;
nsAutoPtr<mozilla::layers::CompositionNotifySink> mNotifySink;

36
dom/plugins/ipc/PluginMessageUtils.h
View File

@ -54,16 +54,6 @@ UnmungePluginDsoPath(const std::string& munged);
extern PRLogModuleInfo* GetPluginLog();
const uint32_t kAllowAsyncDrawing = 0x1;
inline bool IsDrawingModelAsync(int16_t aModel) {
return aModel == NPDrawingModelAsyncBitmapSurface
#ifdef XP_WIN
|| aModel == NPDrawingModelAsyncWindowsDXGISurface
#endif
;
}
#if defined(_MSC_VER)
#define FULLFUNCTION __FUNCSIG__
#elif defined(__GNUC__)
@ -337,32 +327,6 @@ struct ParamTraits<NPWindowType>
}
};
template <>
struct ParamTraits<NPImageFormat>
{
typedef NPImageFormat paramType;
static void Write(Message* aMsg, const paramType& aParam)
{
aMsg->WriteInt16(int16_t(aParam));
}
static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
{
int16_t result;
if (aMsg->ReadInt16(aIter, &result)) {
*aResult = paramType(result);
return true;
}
return false;
}
static void Log(const paramType& aParam, std::wstring* aLog)
{
aLog->append(StringPrintf(L"%d", int16_t(aParam)));
}
};
template <>
struct ParamTraits<mozilla::plugins::NPRemoteWindow>
{

40
dom/plugins/ipc/PluginModuleChild.cpp
View File

@ -945,17 +945,6 @@ _convertpoint(NPP instance,
static void
_urlredirectresponse(NPP instance, void* notifyData, NPBool allow);
static NPError
_initasyncsurface(NPP instance, NPSize *size,
NPImageFormat format, void *initData,
NPAsyncSurface *surface);
static NPError
_finalizeasyncsurface(NPP instance, NPAsyncSurface *surface);
static void
_setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed);
} /* namespace child */
} /* namespace plugins */
} /* namespace mozilla */
@ -1017,10 +1006,7 @@ const NPNetscapeFuncs PluginModuleChild::sBrowserFuncs = {
mozilla::plugins::child::_convertpoint,
nullptr, // handleevent, unimplemented
nullptr, // unfocusinstance, unimplemented
mozilla::plugins::child::_urlredirectresponse,
mozilla::plugins::child::_initasyncsurface,
mozilla::plugins::child::_finalizeasyncsurface,
mozilla::plugins::child::_setcurrentasyncsurface
mozilla::plugins::child::_urlredirectresponse
};
PluginInstanceChild*
@ -1808,26 +1794,6 @@ _urlredirectresponse(NPP instance, void* notifyData, NPBool allow)
InstCast(instance)->NPN_URLRedirectResponse(notifyData, allow);
}
NPError
_initasyncsurface(NPP instance, NPSize *size,
NPImageFormat format, void *initData,
NPAsyncSurface *surface)
{
return InstCast(instance)->NPN_InitAsyncSurface(size, format, initData, surface);
}
NPError
_finalizeasyncsurface(NPP instance, NPAsyncSurface *surface)
{
return InstCast(instance)->NPN_FinalizeAsyncSurface(surface);
}
void
_setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
{
InstCast(instance)->NPN_SetCurrentAsyncSurface(surface, changed);
}
} /* namespace child */
} /* namespace plugins */
} /* namespace mozilla */
@ -1851,13 +1817,11 @@ PluginModuleChild::AnswerNP_GetEntryPoints(NPError* _retval)
}
bool
PluginModuleChild::AnswerNP_Initialize(const uint32_t& aFlags, NPError* _retval)
PluginModuleChild::AnswerNP_Initialize(NPError* _retval)
{
PLUGIN_LOG_DEBUG_METHOD;
AssertPluginThread();
mAsyncDrawingAllowed = aFlags & kAllowAsyncDrawing;
#ifdef OS_WIN
SetEventHooks();
#endif

5
dom/plugins/ipc/PluginModuleChild.h
View File

@ -75,7 +75,7 @@ protected:
// Implement the PPluginModuleChild interface
virtual bool AnswerNP_GetEntryPoints(NPError* rv) MOZ_OVERRIDE;
virtual bool AnswerNP_Initialize(const uint32_t& aFlags, NPError* rv) MOZ_OVERRIDE;
virtual bool AnswerNP_Initialize(NPError* rv) MOZ_OVERRIDE;
virtual PPluginIdentifierChild*
AllocPPluginIdentifierChild(const nsCString& aString,
@ -183,8 +183,6 @@ public:
bool NPObjectIsRegistered(NPObject* aObject);
#endif
bool AsyncDrawingAllowed() { return mAsyncDrawingAllowed; }
/**
* The child implementation of NPN_CreateObject.
*/
@ -315,7 +313,6 @@ private:
nsCString mPluginFilename; // UTF8
nsCString mUserAgent;
int mQuirks;
bool mAsyncDrawingAllowed;
// we get this from the plugin
NP_PLUGINSHUTDOWN mShutdownFunc;

11
dom/plugins/ipc/PluginModuleParent.cpp
View File

@ -1201,9 +1201,7 @@ PluginModuleParent::NP_Initialize(NPNetscapeFuncs* bFuncs, NPPluginFuncs* pFuncs
return NS_ERROR_FAILURE;
}
uint32_t flags = 0;
if (!CallNP_Initialize(flags, error)) {
if (!CallNP_Initialize(error)) {
Close();
return NS_ERROR_FAILURE;
}
@ -1229,12 +1227,7 @@ PluginModuleParent::NP_Initialize(NPNetscapeFuncs* bFuncs, NPError* error)
return NS_ERROR_FAILURE;
}
uint32_t flags = 0;
#ifdef XP_WIN
flags |= kAllowAsyncDrawing;
#endif
if (!CallNP_Initialize(flags, error)) {
if (!CallNP_Initialize(error)) {
Close();
return NS_ERROR_FAILURE;
}

14
dom/plugins/test/reftest/plugin-async-update-ref.html
View File

@ -1,14 +0,0 @@
<!doctype html>
<html><head>
<title>div boxes</title>
<style>
div {
width: 400px;
height: 400px;
display: inline-block;
}
</style>
</head>
<body>
<div style="background-color: #00FF00;"></div> <!-- green -->
</body></html>

10
dom/plugins/test/reftest/plugin-asyncbitmap-sanity.html
View File

@ -1,10 +0,0 @@
<!doctype html>
<html><head>
<title>Plugin boxes</title>
</head>
<body>
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FFFF0000" asyncmodel="bitmap"></embed> <!-- red -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF00FF00" asyncmodel="bitmap"></embed> <!-- green -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF0000FF" asyncmodel="bitmap"></embed> <!-- blue -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF999999" asyncmodel="bitmap"></embed> <!-- gray -->
</body></html>

24
dom/plugins/test/reftest/plugin-asyncbitmap-update.html
View File

@ -1,24 +0,0 @@
<!doctype html>
<html class="reftest-wait"><head>
<title>Plugin boxes</title>
</head>
<body>
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FFFF0000" id="plugin" asyncmodel="bitmap"></embed> <!-- red -->
<script>
var prevPaintCount = 0;
function doTestWait() {
if (window.mozPaintCount != prevPaintCount) {
document.documentElement.removeAttribute('class');
} else {
setTimeout(doTestWait, 0);
}
}
function doTest() {
prevPaintCount = window.mozPaintCount;
document.getElementById("plugin").setColor("FF00FF00");
setTimeout(doTestWait, 0);
}
window.addEventListener("MozReftestInvalidate", doTest, false);
</script>
</body></html>

10
dom/plugins/test/reftest/plugin-asyncdxgi-sanity.html
View File

@ -1,10 +0,0 @@
<!doctype html>
<html><head>
<title>Plugin boxes</title>
</head>
<body>
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FFFF0000" asyncmodel="dxgi"></embed> <!-- red -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF00FF00" asyncmodel="dxgi"></embed> <!-- green -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF0000FF" asyncmodel="dxgi"></embed> <!-- blue -->
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FF999999" asyncmodel="dxgi"></embed> <!-- gray -->
</body></html>

24
dom/plugins/test/reftest/plugin-asyncdxgi-update.html
View File

@ -1,24 +0,0 @@
<!doctype html>
<html class="reftest-wait"><head>
<title>Plugin boxes</title>
</head>
<body>
<embed type="application/x-test" width="400" height="400" drawmode="solid" color="FFFF0000" id="plugin" asyncmodel="dxgi"></embed> <!-- red -->
<script>
var prevPaintCount = 0;
function doTestWait() {
if (window.mozPaintCount != prevPaintCount) {
document.documentElement.removeAttribute('class');
} else {
setTimeout(doTestWait, 0);
}
}
function doTest() {
prevPaintCount = window.mozPaintCount;
document.getElementById("plugin").setColor("FF00FF00");
setTimeout(doTestWait, 0);
}
window.addEventListener("MozReftestInvalidate", doTest, false);
</script>
</body></html>

5
dom/plugins/test/reftest/reftest.list
View File

@ -1,11 +1,6 @@
# basic sanity checking
random-if(!haveTestPlugin) != plugin-sanity.html about:blank
random-if(!haveTestPlugin) != plugin-asyncbitmap-sanity.html about:blank
fails-if(!haveTestPlugin) == plugin-sanity.html div-sanity.html
fails-if(!haveTestPlugin) == plugin-asyncbitmap-sanity.html div-sanity.html
fails-if(!haveTestPlugin) == plugin-asyncdxgi-sanity.html div-sanity.html
random-if(OSX==10.6||OSX==10.7) skip-if(!haveTestPlugin) == plugin-asyncbitmap-update.html plugin-async-update-ref.html
random-if(OSX==10.6||OSX==10.7) skip-if(!haveTestPlugin) == plugin-asyncdxgi-update.html plugin-async-update-ref.html
fails-if(!haveTestPlugin) == plugin-alpha-zindex.html div-alpha-zindex.html
fails-if(!haveTestPlugin) == plugin-alpha-opacity.html div-alpha-opacity.html
random-if(/^Windows\x20NT\x206\.1/.test(http.oscpu)) fails-if(!haveTestPlugin) == windowless-clipping-1.html windowless-clipping-1-ref.html # bug 631832

9
dom/plugins/test/testplugin/README
View File

@ -23,15 +23,6 @@ The plugin will draw a solid color instead of the default rendering described
above. The default solid color is completely transparent black (i.e., nothing).
This should be specified when using one of the async models.
* asyncmodel="bitmap"
The plugin will use the NPAPI Async Bitmap drawing model extension. On
unsupported platforms this will fallback to non-async rendering.
* asyncmodel="dxgi"
The plugin will use the NPAPI Async DXGI drawing model extension. Only
supported on Windows Vista or higher. On unsupported platforms this will
fallback to non-async rendering.
* color
This specifies the color to use for drawmode="solid". The value should be 8 hex
digits, 2 per channel in AARRGGBB format.

139
dom/plugins/test/testplugin/nptest.cpp
View File

@ -562,39 +562,6 @@ DuplicateNPVariant(NPVariant& aDest, const NPVariant& aSrc)
}
}
void
drawAsyncBitmapColor(InstanceData* instanceData)
{
NPP npp = instanceData->npp;
uint32_t *pixelData = (uint32_t*)instanceData->backBuffer->bitmap.data;
uint32_t rgba = instanceData->scriptableObject->drawColor;
unsigned char subpixels[4];
subpixels[0] = rgba & 0xFF;
subpixels[1] = (rgba & 0xFF00) >> 8;
subpixels[2] = (rgba & 0xFF0000) >> 16;
subpixels[3] = (rgba & 0xFF000000) >> 24;
subpixels[0] = uint8_t(float(subpixels[3] * subpixels[0]) / 0xFF);
subpixels[1] = uint8_t(float(subpixels[3] * subpixels[1]) / 0xFF);
subpixels[2] = uint8_t(float(subpixels[3] * subpixels[2]) / 0xFF);
uint32_t premultiplied;
memcpy(&premultiplied, subpixels, sizeof(premultiplied));
for (uint32_t* lastPixel = pixelData + instanceData->backBuffer->size.width * instanceData->backBuffer->size.height;
pixelData < lastPixel;
++pixelData) {
*pixelData = premultiplied;
}
NPN_SetCurrentAsyncSurface(npp, instanceData->backBuffer, nullptr);
NPAsyncSurface *oldFront = instanceData->frontBuffer;
instanceData->frontBuffer = instanceData->backBuffer;
instanceData->backBuffer = oldFront;
}
static bool bug813906(NPP npp, const char* const function, const char* const url, const char* const frame)
{
NPObject *windowObj = nullptr;
@ -829,9 +796,6 @@ NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char*
instanceData->eventModel = 0;
instanceData->closeStream = false;
instanceData->wantsAllStreams = false;
instanceData->asyncDrawing = AD_NONE;
instanceData->frontBuffer = nullptr;
instanceData->backBuffer = nullptr;
instanceData->mouseUpEventCount = 0;
instanceData->bugMode = -1;
instance->pdata = instanceData;
@ -870,18 +834,6 @@ NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char*
requestWindow = true;
}
}
else if (strcmp(argn[i], "asyncmodel") == 0) {
if (strcmp(argv[i], "bitmap") == 0) {
if (pluginSupportsAsyncBitmapDrawing()) {
instanceData->asyncDrawing = AD_BITMAP;
}
}
if (strcmp(argv[i], "dxgi") == 0) {
if (pluginSupportsAsyncDXGIDrawing()) {
instanceData->asyncDrawing = AD_DXGI;
}
}
}
if (strcmp(argn[i], "streammode") == 0) {
if (strcmp(argv[i], "normal") == 0) {
instanceData->streamMode = NP_NORMAL;
@ -996,27 +948,6 @@ NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char*
NPN_SetValue(instance, NPPVpluginTransparentBool, (void*)true);
}
if (instanceData->asyncDrawing == AD_BITMAP) {
NPBool supportsAsyncBitmap = false;
if ((NPN_GetValue(instance, NPNVsupportsAsyncBitmapSurfaceBool, &supportsAsyncBitmap) == NPERR_NO_ERROR) &&
supportsAsyncBitmap) {
NPN_SetValue(instance, NPPVpluginDrawingModel, (void*)NPDrawingModelAsyncBitmapSurface);
} else {
instanceData->asyncDrawing = AD_NONE;
}
}
#ifdef XP_WIN
else if (instanceData->asyncDrawing == AD_DXGI) {
NPBool supportsAsyncDXGI = false;
if ((NPN_GetValue(instance, NPNVsupportsAsyncWindowsDXGISurfaceBool, &supportsAsyncDXGI) == NPERR_NO_ERROR) &&
supportsAsyncDXGI) {
NPN_SetValue(instance, NPPVpluginDrawingModel, (void*)NPDrawingModelAsyncWindowsDXGISurface);
} else {
instanceData->asyncDrawing = AD_NONE;
}
}
#endif
instanceData->lastReportedPrivateModeState = false;
instanceData->lastMouseX = instanceData->lastMouseY = -1;
instanceData->widthAtLastPaint = -1;
@ -1108,16 +1039,6 @@ NPP_Destroy(NPP instance, NPSavedData** save)
currentrange = nextrange;
}
if (instanceData->frontBuffer) {
NPN_SetCurrentAsyncSurface(instance, nullptr, nullptr);
NPN_FinalizeAsyncSurface(instance, instanceData->frontBuffer);
NPN_MemFree(instanceData->frontBuffer);
}
if (instanceData->backBuffer) {
NPN_FinalizeAsyncSurface(instance, instanceData->backBuffer);
NPN_MemFree(instanceData->backBuffer);
}
pluginInstanceShutdown(instanceData);
NPN_ReleaseObject(instanceData->scriptableObject);
@ -1150,36 +1071,6 @@ NPP_SetWindow(NPP instance, NPWindow* window)
pluginWidgetInit(instanceData, oldWindow);
}
if (instanceData->asyncDrawing == AD_BITMAP) {
if (instanceData->frontBuffer &&
instanceData->frontBuffer->size.width >= 0 &&
(uint32_t)instanceData->frontBuffer->size.width == window->width &&
instanceData ->frontBuffer->size.height >= 0 &&
(uint32_t)instanceData->frontBuffer->size.height == window->height) {
return NPERR_NO_ERROR;
}
if (instanceData->frontBuffer) {
NPN_FinalizeAsyncSurface(instance, instanceData->frontBuffer);
NPN_MemFree(instanceData->frontBuffer);
}
if (instanceData->backBuffer) {
NPN_FinalizeAsyncSurface(instance, instanceData->backBuffer);
NPN_MemFree(instanceData->backBuffer);
}
instanceData->frontBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
instanceData->backBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
NPSize size;
size.width = window->width;
size.height = window->height;
memcpy(instanceData->backBuffer, instanceData->frontBuffer, sizeof(NPAsyncSurface));
NPN_InitAsyncSurface(instance, &size, NPImageFormatBGRA32, nullptr, instanceData->frontBuffer);
NPN_InitAsyncSurface(instance, &size, NPImageFormatBGRA32, nullptr, instanceData->backBuffer);
drawAsyncBitmapColor(instanceData);
}
return NPERR_NO_ERROR;
}
@ -1932,25 +1823,6 @@ NPN_URLRedirectResponse(NPP instance, void* notifyData, NPBool allow)
return sBrowserFuncs->urlredirectresponse(instance, notifyData, allow);
}
NPError
NPN_InitAsyncSurface(NPP instance, NPSize *size, NPImageFormat format,
void *initData, NPAsyncSurface *surface)
{
return sBrowserFuncs->initasyncsurface(instance, size, format, initData, surface);
}
NPError
NPN_FinalizeAsyncSurface(NPP instance, NPAsyncSurface *surface)
{
return sBrowserFuncs->finalizeasyncsurface(instance, surface);
}
void
NPN_SetCurrentAsyncSurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
{
sBrowserFuncs->setcurrentasyncsurface(instance, surface, changed);
}
//
// npruntime object functions
//
@ -2848,16 +2720,7 @@ setColor(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* r
r.top = 0;
r.right = id->window.width;
r.bottom = id->window.height;
if (id->asyncDrawing == AD_NONE) {
NPN_InvalidateRect(npp, &r);
} else if (id->asyncDrawing == AD_BITMAP) {
drawAsyncBitmapColor(id);
}
#ifdef XP_WIN
else if (id->asyncDrawing == AD_DXGI) {
pluginDrawAsyncDxgiColor(id);
}
#endif
NPN_InvalidateRect(npp, &r);
VOID_TO_NPVARIANT(*result);
return true;

9
dom/plugins/test/testplugin/nptest.h
View File

@ -61,12 +61,6 @@ typedef enum {
FUNCTION_NPP_WRITE_RPC
} TestFunction;
typedef enum {
AD_NONE,
AD_BITMAP,
AD_DXGI
} AsyncDrawing;
typedef enum {
ACTIVATION_STATE_UNKNOWN,
ACTIVATION_STATE_ACTIVATED,
@ -148,9 +142,6 @@ typedef struct InstanceData {
bool closeStream;
std::string lastKeyText;
bool wantsAllStreams;
AsyncDrawing asyncDrawing;
NPAsyncSurface *frontBuffer;
NPAsyncSurface *backBuffer;
int32_t mouseUpEventCount;
int32_t bugMode;
std::string javaCodebase;

6
dom/plugins/test/testplugin/nptest_droid.cpp
View File

@ -49,12 +49,6 @@ pluginSupportsWindowlessMode()
return true;
}
bool
pluginSupportsAsyncBitmapDrawing()
{
return false;
}
NPError
pluginInstanceInit(InstanceData* instanceData)
{

6
dom/plugins/test/testplugin/nptest_gtk2.cpp
View File

@ -71,12 +71,6 @@ pluginSupportsWindowlessMode()
return true;
}
bool
pluginSupportsAsyncBitmapDrawing()
{
return false;
}
NPError
pluginInstanceInit(InstanceData* instanceData)
{

6
dom/plugins/test/testplugin/nptest_macosx.mm
View File

@ -50,12 +50,6 @@ pluginSupportsWindowlessMode()
return true;
}
bool
pluginSupportsAsyncBitmapDrawing()
{
return false;
}
NPError
pluginInstanceInit(InstanceData* instanceData)
{

21
dom/plugins/test/testplugin/nptest_platform.h
View File

@ -48,23 +48,6 @@ bool pluginSupportsWindowMode();
*/
bool pluginSupportsWindowlessMode();
/**
* Returns true if the plugin supports async bitmap drawing.
*/
bool pluginSupportsAsyncBitmapDrawing();
/**
* Returns true if the plugin supports DXGI bitmap drawing.
*/
inline bool pluginSupportsAsyncDXGIDrawing()
{
#ifdef XP_WIN
return true;
#else
return false;
#endif
}
/**
* Initialize the plugin instance. Returning an error here will cause the
* plugin instantiation to fail.
@ -93,10 +76,6 @@ void pluginWidgetInit(InstanceData* instanceData, void* oldWindow);
*/
int16_t pluginHandleEvent(InstanceData* instanceData, void* event);
#ifdef XP_WIN
void pluginDrawAsyncDxgiColor(InstanceData* instanceData);
#endif
enum RectEdge {
EDGE_LEFT = 0,
EDGE_TOP = 1,

6
dom/plugins/test/testplugin/nptest_qt.cpp
View File

@ -47,12 +47,6 @@ pluginSupportsWindowlessMode()
return true;
}
bool
pluginSupportsAsyncBitmapDrawing()
{
return false;
}
NPError
pluginInstanceInit(InstanceData* instanceData)
{

156
dom/plugins/test/testplugin/nptest_windows.cpp
View File

@ -65,12 +65,6 @@ pluginSupportsWindowlessMode()
return true;
}
bool
pluginSupportsAsyncBitmapDrawing()
{
return true;
}
NPError
pluginInstanceInit(InstanceData* instanceData)
{
@ -105,118 +99,10 @@ pluginInstanceShutdown(InstanceData* instanceData)
instanceData->platformData = 0;
}
static ID3D10Device1*
getD3D10Device()
{
ID3D10Device1 *device;
HMODULE d3d10module = LoadLibraryA("d3d10_1.dll");
decltype(D3D10CreateDevice1)* createD3DDevice =
(decltype(D3D10CreateDevice1)*) GetProcAddress(d3d10module,
"D3D10CreateDevice1");
if (createD3DDevice) {
HMODULE dxgiModule = LoadLibraryA("dxgi.dll");
decltype(CreateDXGIFactory1)* createDXGIFactory1 =
(decltype(CreateDXGIFactory1)*) GetProcAddress(dxgiModule,
"CreateDXGIFactory1");
HRESULT hr;
// Try to use a DXGI 1.1 adapter in order to share resources
// across processes.
IDXGIAdapter1 *adapter1;
if (createDXGIFactory1) {
IDXGIFactory1 *factory1;
hr = createDXGIFactory1(__uuidof(IDXGIFactory1),
(void**)&factory1);
if (FAILED(hr) || !factory1) {
// Uh-oh
return nullptr;
}
hr = factory1->EnumAdapters1(0, &adapter1);
if (SUCCEEDED(hr) && adapter1) {
hr = adapter1->CheckInterfaceSupport(__uuidof(ID3D10Device),
nullptr);
if (FAILED(hr)) {
adapter1 = nullptr;
}
}
factory1->Release();
}
hr = createD3DDevice(
adapter1,
D3D10_DRIVER_TYPE_HARDWARE,
nullptr,
D3D10_CREATE_DEVICE_BGRA_SUPPORT |
D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS,
D3D10_FEATURE_LEVEL_10_0,
D3D10_1_SDK_VERSION,
&device);
adapter1->Release();
}
return device;
}
void
pluginDoSetWindow(InstanceData* instanceData, NPWindow* newWindow)
{
instanceData->window = *newWindow;
NPP npp = instanceData->npp;
if (instanceData->asyncDrawing == AD_DXGI) {
if (instanceData->frontBuffer &&
instanceData->frontBuffer->size.width == newWindow->width &&
instanceData->frontBuffer->size.height == newWindow->height) {
return;
}
if (instanceData->frontBuffer) {
instanceData->platformData->frontBuffer->Release();
instanceData->platformData->frontBuffer = nullptr;
NPN_FinalizeAsyncSurface(npp, instanceData->frontBuffer);
NPN_MemFree(instanceData->frontBuffer);
}
if (instanceData->backBuffer) {
instanceData->platformData->backBuffer->Release();
instanceData->platformData->backBuffer = nullptr;
NPN_FinalizeAsyncSurface(npp, instanceData->backBuffer);
NPN_MemFree(instanceData->backBuffer);
}
if (!instanceData->platformData->device) {
instanceData->platformData->device = getD3D10Device();
}
ID3D10Device1 *dev = instanceData->platformData->device;
if (!dev) {
return;
}
instanceData->frontBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
instanceData->backBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
NPSize size;
size.width = newWindow->width;
size.height = newWindow->height;
memset(instanceData->frontBuffer, 0, sizeof(NPAsyncSurface));
memset(instanceData->backBuffer, 0, sizeof(NPAsyncSurface));
NPN_InitAsyncSurface(npp, &size, NPImageFormatBGRA32, nullptr, instanceData->frontBuffer);
NPN_InitAsyncSurface(npp, &size, NPImageFormatBGRA32, nullptr, instanceData->backBuffer);
dev->OpenSharedResource(instanceData->frontBuffer->sharedHandle, __uuidof(ID3D10Texture2D), (void**)&instanceData->platformData->frontBuffer);
dev->OpenSharedResource(instanceData->backBuffer->sharedHandle, __uuidof(ID3D10Texture2D), (void**)&instanceData->platformData->backBuffer);
pluginDrawAsyncDxgiColor(instanceData);
}
}
#define CHILD_WIDGET_SIZE 10
@ -705,45 +591,3 @@ void pluginDoInternalConsistencyCheck(InstanceData* instanceData, string& error)
checkEquals(childRect.bottom, childRect.top + CHILD_WIDGET_SIZE, "Child widget height", error);
}
}
void
pluginDrawAsyncDxgiColor(InstanceData* id)
{
PlatformData *pd = id->platformData;
ID3D10Device1 *dev = pd->device;
IDXGIKeyedMutex *mutex;
pd->backBuffer->QueryInterface(&mutex);
mutex->AcquireSync(0, INFINITE);
ID3D10RenderTargetView *rtView;
dev->CreateRenderTargetView(pd->backBuffer, nullptr, &rtView);
uint32_t rgba = id->scriptableObject->drawColor;
unsigned char subpixels[4];
subpixels[0] = rgba & 0xFF;
subpixels[1] = (rgba & 0xFF00) >> 8;
subpixels[2] = (rgba & 0xFF0000) >> 16;
subpixels[3] = (rgba & 0xFF000000) >> 24;
float color[4];
color[2] = float(subpixels[3] * subpixels[0]) / 0xFE01;
color[1] = float(subpixels[3] * subpixels[1]) / 0xFE01;
color[0] = float(subpixels[3] * subpixels[2]) / 0xFE01;
color[3] = float(subpixels[3]) / 0xFF;
dev->ClearRenderTargetView(rtView, color);
rtView->Release();
mutex->ReleaseSync(0);
mutex->Release();
NPN_SetCurrentAsyncSurface(id->npp, id->backBuffer, nullptr);
NPAsyncSurface *oldFront = id->frontBuffer;
id->frontBuffer = id->backBuffer;
id->backBuffer = oldFront;
ID3D10Texture2D *oldFrontT = pd->frontBuffer;
pd->frontBuffer = pd->backBuffer;
pd->backBuffer = oldFrontT;
}