mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
275 lines
8.8 KiB
Plaintext
275 lines
8.8 KiB
Plaintext
/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
|
|
/* 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 protocol PPluginBackgroundDestroyer;
|
|
include protocol PPluginModule;
|
|
include protocol PPluginScriptableObject;
|
|
include protocol PBrowserStream;
|
|
include protocol PPluginStream;
|
|
include protocol PStreamNotify;
|
|
include protocol PPluginSurface;
|
|
|
|
include "mozilla/plugins/PluginMessageUtils.h";
|
|
include "IPC/nsGUIEventIPC.h";
|
|
|
|
using NPError;
|
|
using NPRemoteWindow;
|
|
using NPRemoteEvent;
|
|
using NPRect;
|
|
using NPImageFormat;
|
|
using NPNURLVariable;
|
|
using NPCoordinateSpace;
|
|
using NPNVariable;
|
|
using mozilla::plugins::NativeWindowHandle;
|
|
using mozilla::gfxSurfaceType;
|
|
using gfxIntSize;
|
|
using mozilla::null_t;
|
|
using mozilla::plugins::WindowsSharedMemoryHandle;
|
|
using mozilla::plugins::DXGISharedSurfaceHandle;
|
|
using mozilla::CrossProcessMutexHandle;
|
|
using SurfaceDescriptorX11;
|
|
using nsIntRect;
|
|
using nsTextEvent;
|
|
using nsKeyEvent;
|
|
|
|
namespace mozilla {
|
|
namespace plugins {
|
|
|
|
struct IOSurfaceDescriptor {
|
|
uint32_t surfaceId;
|
|
};
|
|
|
|
union SurfaceDescriptor {
|
|
Shmem;
|
|
SurfaceDescriptorX11;
|
|
PPluginSurface; // used on Windows
|
|
IOSurfaceDescriptor; // used on OSX 10.5+
|
|
// Descriptor can be null here in case
|
|
// 1) of first Show call (prevSurface is null)
|
|
// 2) when child is going to destroy
|
|
// and it just want to grab prevSurface
|
|
// back without giving new surface
|
|
null_t;
|
|
};
|
|
|
|
union OptionalShmem {
|
|
Shmem;
|
|
null_t;
|
|
};
|
|
|
|
union AsyncSurfaceDescriptor {
|
|
Shmem;
|
|
DXGISharedSurfaceHandle;
|
|
};
|
|
|
|
struct NPRemoteAsyncSurface
|
|
{
|
|
uint32_t version;
|
|
gfxIntSize size;
|
|
NPImageFormat format;
|
|
uint32_t stride;
|
|
AsyncSurfaceDescriptor data;
|
|
uintptr_t hostPtr;
|
|
};
|
|
|
|
rpc protocol PPluginInstance
|
|
{
|
|
manager PPluginModule;
|
|
|
|
manages PPluginBackgroundDestroyer;
|
|
manages PPluginScriptableObject;
|
|
manages PBrowserStream;
|
|
manages PPluginStream;
|
|
manages PStreamNotify;
|
|
manages PPluginSurface;
|
|
|
|
child:
|
|
rpc __delete__();
|
|
|
|
rpc NPP_SetWindow(NPRemoteWindow window);
|
|
|
|
rpc NPP_GetValue_NPPVpluginWantsAllNetworkStreams()
|
|
returns (bool value, NPError result);
|
|
|
|
// this message is not used on non-X platforms
|
|
rpc NPP_GetValue_NPPVpluginNeedsXEmbed()
|
|
returns (bool value, NPError result);
|
|
|
|
rpc NPP_GetValue_NPPVpluginScriptableNPObject()
|
|
returns (nullable PPluginScriptableObject value, NPError result);
|
|
|
|
rpc NPP_SetValue_NPNVprivateModeBool(bool value) returns (NPError result);
|
|
rpc NPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId()
|
|
returns (nsCString plug_id, NPError result);
|
|
|
|
rpc NPP_HandleEvent(NPRemoteEvent event)
|
|
returns (int16_t handled);
|
|
// special cases where we need to a shared memory buffer
|
|
rpc NPP_HandleEvent_Shmem(NPRemoteEvent event, Shmem buffer)
|
|
returns (int16_t handled, Shmem rtnbuffer);
|
|
// special cases where we need an iosurface
|
|
rpc NPP_HandleEvent_IOSurface(NPRemoteEvent event, uint32_t surfaceid)
|
|
returns (int16_t handled);
|
|
// special cases of HandleEvent to make mediating races simpler
|
|
rpc Paint(NPRemoteEvent event)
|
|
returns (int16_t handled);
|
|
// this is only used on windows to forward WM_WINDOWPOSCHANGE
|
|
async WindowPosChanged(NPRemoteEvent event);
|
|
|
|
// ********************** Async plugins rendering
|
|
// see https://wiki.mozilla.org/Gecko:AsyncPluginPainting
|
|
// **********************
|
|
|
|
// Async version of SetWindow call
|
|
// @param surfaceType - gfxASurface::gfxSurfaceType
|
|
// plugin child must create offscreen buffer
|
|
// with type equals to surfaceType
|
|
async AsyncSetWindow(gfxSurfaceType surfaceType, NPRemoteWindow window);
|
|
|
|
// There is now an opaque background behind this instance (or the
|
|
// background was updated). The changed area is |rect|. The
|
|
// browser owns the background surface, and it's read-only from
|
|
// within the plugin process. |background| is either null_t to
|
|
// refer to the existing background or a fresh descriptor.
|
|
async UpdateBackground(SurfaceDescriptor background, nsIntRect rect);
|
|
|
|
rpc HandleTextEvent(nsTextEvent event)
|
|
returns (bool handled);
|
|
rpc HandleKeyEvent(nsKeyEvent event)
|
|
returns (bool handled);
|
|
|
|
async NPP_DidComposite();
|
|
|
|
rpc NPP_Destroy()
|
|
returns (NPError rv);
|
|
|
|
parent:
|
|
rpc NPN_GetValue_NPNVjavascriptEnabledBool()
|
|
returns (bool value, NPError result);
|
|
rpc NPN_GetValue_NPNVisOfflineBool()
|
|
returns (bool value, NPError result);
|
|
rpc NPN_GetValue_NPNVWindowNPObject()
|
|
returns (nullable PPluginScriptableObject value, NPError result);
|
|
rpc NPN_GetValue_NPNVPluginElementNPObject()
|
|
returns (nullable PPluginScriptableObject value, NPError result);
|
|
rpc NPN_GetValue_NPNVprivateModeBool()
|
|
returns (bool value, NPError result);
|
|
rpc NPN_GetValue_NPNVnetscapeWindow()
|
|
returns (NativeWindowHandle value, NPError result);
|
|
rpc NPN_GetValue_NPNVdocumentOrigin()
|
|
returns (nsCString value, NPError result);
|
|
rpc NPN_GetValue_DrawingModelSupport(NPNVariable model)
|
|
returns (bool value);
|
|
|
|
rpc NPN_SetValue_NPPVpluginWindow(bool windowed)
|
|
returns (NPError result);
|
|
rpc NPN_SetValue_NPPVpluginTransparent(bool transparent)
|
|
returns (NPError result);
|
|
rpc NPN_SetValue_NPPVpluginUsesDOMForCursor(bool useDOMForCursor)
|
|
returns (NPError result);
|
|
rpc NPN_SetValue_NPPVpluginDrawingModel(int drawingModel)
|
|
returns (OptionalShmem remoteImageData, CrossProcessMutexHandle mutex, NPError result);
|
|
rpc NPN_SetValue_NPPVpluginEventModel(int eventModel)
|
|
returns (NPError result);
|
|
|
|
rpc NPN_GetURL(nsCString url, nsCString target)
|
|
returns (NPError result);
|
|
rpc NPN_PostURL(nsCString url, nsCString target, nsCString buffer, bool file)
|
|
returns (NPError result);
|
|
|
|
/**
|
|
* Covers both NPN_GetURLNotify and NPN_PostURLNotify.
|
|
* @TODO This would be more readable as an overloaded method,
|
|
* but IPDL doesn't allow that for constructors.
|
|
*/
|
|
rpc PStreamNotify(nsCString url, nsCString target, bool post,
|
|
nsCString buffer, bool file)
|
|
returns (NPError result);
|
|
|
|
async NPN_InvalidateRect(NPRect rect);
|
|
|
|
// Give |newSurface|, containing this instance's updated pixels, to
|
|
// the browser for compositing. When this method returns, any surface
|
|
// previously passed to Show may be destroyed.
|
|
//
|
|
// @param rect - actually updated rectangle, comparing to prevSurface content
|
|
// could be used for partial render of layer to topLevel context
|
|
// @param newSurface - remotable surface
|
|
// @param prevSurface - if the previous surface was shared-memory, returns
|
|
// the shmem for reuse
|
|
sync Show(NPRect updatedRect, SurfaceDescriptor newSurface)
|
|
returns (SurfaceDescriptor prevSurface);
|
|
|
|
async PPluginSurface(WindowsSharedMemoryHandle handle,
|
|
gfxIntSize size,
|
|
bool transparent);
|
|
|
|
rpc NPN_PushPopupsEnabledState(bool aState);
|
|
|
|
rpc NPN_PopPopupsEnabledState();
|
|
|
|
rpc NPN_GetValueForURL(NPNURLVariable variable, nsCString url)
|
|
returns (nsCString value, NPError result);
|
|
|
|
rpc NPN_SetValueForURL(NPNURLVariable variable, nsCString url,
|
|
nsCString value)
|
|
returns (NPError result);
|
|
|
|
rpc NPN_GetAuthenticationInfo(nsCString protocol_, nsCString host,
|
|
int32_t port, nsCString scheme,
|
|
nsCString realm)
|
|
returns (nsCString username, nsCString password, NPError result);
|
|
|
|
rpc NPN_ConvertPoint(double sourceX, bool ignoreDestX, double sourceY, bool ignoreDestY, NPCoordinateSpace sourceSpace,
|
|
NPCoordinateSpace destSpace)
|
|
returns (double destX, double destY, bool result);
|
|
|
|
async RedrawPlugin();
|
|
|
|
rpc 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();
|
|
|
|
child:
|
|
/* NPP_NewStream */
|
|
rpc PBrowserStream(nsCString url,
|
|
uint32_t length,
|
|
uint32_t lastmodified,
|
|
nullable PStreamNotify notifyData,
|
|
nsCString headers,
|
|
nsCString mimeType,
|
|
bool seekable)
|
|
returns (NPError rv,
|
|
uint16_t stype);
|
|
|
|
parent:
|
|
/* NPN_NewStream */
|
|
rpc PPluginStream(nsCString mimeType,
|
|
nsCString target)
|
|
returns (NPError result);
|
|
|
|
parent:
|
|
rpc PluginFocusChange(bool gotFocus);
|
|
|
|
child:
|
|
rpc SetPluginFocus();
|
|
rpc UpdateWindow();
|
|
|
|
async PPluginBackgroundDestroyer();
|
|
};
|
|
|
|
} // namespace plugins
|
|
} // namespace mozilla
|