DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (5350524bb654)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
/* -*- 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/GfxMessageUtils.h";

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 NPNURLVariable from "npapi.h";
using NPCoordinateSpace from "npapi.h";
using NPNVariable from "npapi.h";
using mozilla::plugins::NativeWindowHandle from "mozilla/plugins/PluginMessageUtils.h";
using gfxSurfaceType from "gfxTypes.h";
using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
using mozilla::gfx::IntRect from "mozilla/gfx/2D.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h";
using mozilla::plugins::WindowsSharedMemoryHandle from "mozilla/plugins/PluginMessageUtils.h";
using mozilla::layers::SurfaceDescriptorX11 from "gfxipc/ShadowLayerUtils.h";
using nsIntRect from "nsRect.h";
using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
using struct DxgiAdapterDesc from "mozilla/D3DMessageUtils.h";
using struct mozilla::widget::CandidateWindowPosition from "ipc/nsGUIEventIPC.h";
using class mozilla::NativeEventData from "ipc/nsGUIEventIPC.h";

namespace mozilla {
namespace plugins {

struct IOSurfaceDescriptor {
  uint32_t surfaceId;
  double contentsScaleFactor;
};

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;
};

intr protocol PPluginInstance
{
  manager PPluginModule;

  manages PPluginBackgroundDestroyer;
  manages PPluginScriptableObject;
  manages PBrowserStream;
  manages PPluginStream;
  manages PStreamNotify;
  manages PPluginSurface;

child:
  intr __delete__();

  // This is only used on Windows and, for windowed plugins, must be called
  // before the first call to NPP_SetWindow.
  intr CreateChildPluginWindow()
    returns (NativeWindowHandle childPluginWindow);

  // This is only used on Windows and, for windowless plugins.
  async CreateChildPopupSurrogate(NativeWindowHandle netscapeWindow);

  intr NPP_SetWindow(NPRemoteWindow window);

  intr NPP_GetValue_NPPVpluginWantsAllNetworkStreams()
    returns (bool value, NPError result);

  // this message is not used on non-X platforms
  intr NPP_GetValue_NPPVpluginNeedsXEmbed()
    returns (bool value, NPError result);

  intr NPP_GetValue_NPPVpluginScriptableNPObject()
    returns (nullable PPluginScriptableObject value, NPError result);

  intr NPP_SetValue_NPNVprivateModeBool(bool value) returns (NPError result);
  intr NPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId()
    returns (nsCString plug_id, NPError result);

  intr NPP_SetValue_NPNVCSSZoomFactor(double value) returns (NPError result);

  intr NPP_SetValue_NPNVmuteAudioBool(bool muted) returns (NPError result);

  intr NPP_HandleEvent(NPRemoteEvent event)
    returns (int16_t handled);
  // special cases where we need to a shared memory buffer
  intr NPP_HandleEvent_Shmem(NPRemoteEvent event, Shmem buffer)
    returns (int16_t handled, Shmem rtnbuffer);
  // special cases where we need an iosurface
  intr NPP_HandleEvent_IOSurface(NPRemoteEvent event, uint32_t surfaceid)
    returns (int16_t handled);
  // special cases of HandleEvent to make mediating races simpler
  intr Paint(NPRemoteEvent event)
    returns (int16_t handled);
  // this is only used on windows to forward WM_WINDOWPOSCHANGE
  async WindowPosChanged(NPRemoteEvent event);
  // used on OS X to tell the child the contents scale factor
  // of its parent has changed
  async ContentsScaleFactorChanged(double aContentsScaleFactor);

  // ********************** 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);

  async NPP_DidComposite();

  intr NPP_Destroy()
    returns (NPError rv);

  // HandledWindowedPluginKeyEvent() is always called after posting a native
  // key event with OnWindowedPluginKeyEvent().
  //
  // @param aKeyEventData      The key event which was posted to the parent
  //                           process.
  // @param aIsConsumed        true if aKeyEventData is consumed in the
  //                           parent process.  Otherwise, false.
  async HandledWindowedPluginKeyEvent(NativeEventData aKeyEventData,
                                      bool aIsConsumed);

parent:
  intr NPN_GetValue_NPNVWindowNPObject()
    returns (nullable PPluginScriptableObject value, NPError result);
  intr NPN_GetValue_NPNVPluginElementNPObject()
    returns (nullable PPluginScriptableObject value, NPError result);
  intr NPN_GetValue_NPNVprivateModeBool()
    returns (bool value, NPError result);
  intr NPN_GetValue_NPNVnetscapeWindow()
    returns (NativeWindowHandle value, NPError result);
  intr NPN_GetValue_NPNVdocumentOrigin()
    returns (nsCString value, NPError result);
  intr NPN_GetValue_DrawingModelSupport(NPNVariable model)
    returns (bool value);
  intr NPN_GetValue_SupportsAsyncBitmapSurface()
    returns (bool value);
  intr NPN_GetValue_SupportsAsyncDXGISurface()
    returns (bool value);
  intr NPN_GetValue_PreferredDXGIAdapter()
    returns (DxgiAdapterDesc desc);

  intr NPN_SetValue_NPPVpluginWindow(bool windowed)
    returns (NPError result);
  intr NPN_SetValue_NPPVpluginTransparent(bool transparent)
    returns (NPError result);
  intr NPN_SetValue_NPPVpluginUsesDOMForCursor(bool useDOMForCursor)
    returns (NPError result);
  intr NPN_SetValue_NPPVpluginDrawingModel(int drawingModel)
    returns (NPError result);
  intr NPN_SetValue_NPPVpluginEventModel(int eventModel)
    returns (NPError result);
  intr NPN_SetValue_NPPVpluginIsPlayingAudio(bool isAudioPlaying)
    returns (NPError result);

  intr NPN_GetURL(nsCString url, nsCString target)
    returns (NPError result);
  intr 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.
   */
  intr PStreamNotify(nsCString url, nsCString target, bool post,
                    nsCString buffer, bool file)
    returns (NPError result);

  async NPN_InvalidateRect(NPRect rect);

  // Clear the current plugin image.
  sync RevokeCurrentDirectSurface();

  // Create a new DXGI shared surface with the given format and size. The
  // returned handle, on success, can be opened as an ID3D10Texture2D or
  // ID3D11Texture2D on a corresponding device.
  sync InitDXGISurface(SurfaceFormat format, IntSize size)
    returns (WindowsHandle handle, NPError result);

  // Destroy a surface previously allocated with InitDXGISurface().
  sync FinalizeDXGISurface(WindowsHandle handle);

  // Set the current plugin image to the bitmap in the given shmem buffer. The
  // format must be B8G8R8A8 or B8G8R8X8.
  sync ShowDirectBitmap(Shmem buffer,
                        SurfaceFormat format,
                        uint32_t stride,
                        IntSize size,
                        IntRect dirty);

  // Set the current plugin image to the DXGI surface in |handle|.
  sync ShowDirectDXGISurface(WindowsHandle handle,
                              IntRect dirty);

  // 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,
                       IntSize size,
                       bool transparent);

  intr NPN_PushPopupsEnabledState(bool aState);

  intr NPN_PopPopupsEnabledState();

  intr NPN_GetValueForURL(NPNURLVariable variable, nsCString url)
    returns (nsCString value, NPError result);

  intr NPN_SetValueForURL(NPNURLVariable variable, nsCString url,
                         nsCString value)
    returns (NPError result);

  intr NPN_GetAuthenticationInfo(nsCString protocol_, nsCString host,
                                int32_t port, nsCString scheme,
                                nsCString realm)
    returns (nsCString username, nsCString password, NPError result);

  intr NPN_ConvertPoint(double sourceX, bool ignoreDestX, double sourceY, bool ignoreDestY, NPCoordinateSpace sourceSpace,
                       NPCoordinateSpace destSpace)
    returns (double destX, double destY, bool result);

  async RedrawPlugin();

  // 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 the parent of its NPP_New result code.
  async AsyncNPP_NewResult(NPError aResult);

  // Sends a native window to be adopted by the native window that would be
  // returned by NPN_GetValue_NPNVnetscapeWindow. Only used on Windows.
  async SetNetscapeWindowAsParent(NativeWindowHandle childWindow);

  sync GetCompositionString(uint32_t aType)
                            returns (uint8_t[] aDist, int32_t aLength);
  // Set candidate window position.
  //
  // @param aPosition  position information of candidate window
  async SetCandidateWindow(CandidateWindowPosition aPosition);
  async RequestCommitOrCancel(bool aCommitted);

  // Notifies the parent process of a plugin instance receiving key event
  // directly.
  //
  // @param aKeyEventData       The native key event which will be sent to
  //                            plugin from native event handler.
  async OnWindowedPluginKeyEvent(NativeEventData aKeyEventData);

both:
  async PPluginScriptableObject();

child:
  /* NPP_NewStream */
  async PBrowserStream(nsCString url,
                       uint32_t length,
                       uint32_t lastmodified,
                       nullable PStreamNotify notifyData,
                       nsCString headers);

  // Implements the legacy (synchronous) version of NPP_NewStream for when
  // async plugin init is preffed off.
  intr NPP_NewStream(PBrowserStream actor, nsCString mimeType, bool seekable)
    returns (NPError rv,
             uint16_t stype);

  // Implements the async plugin init version of NPP_NewStream.
  async AsyncNPP_NewStream(PBrowserStream actor, nsCString mimeType, bool seekable);

parent:
  /* NPN_NewStream */
  intr PPluginStream(nsCString mimeType,
                    nsCString target)
    returns (NPError result);

parent:
  intr PluginFocusChange(bool gotFocus);

child:
  intr SetPluginFocus();
  intr UpdateWindow();

  async PPluginBackgroundDestroyer();
};

} // namespace plugins
} // namespace mozilla