The Tor Browser / file comparison

comparison: dom/plugins/ipc/PluginInstanceChild.h

dom/plugins/ipc/PluginInstanceChild.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:9fa20c84d05f
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * vim: sw=4 ts=4 et :
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #ifndef dom_plugins_PluginInstanceChild_h
8 #define dom_plugins_PluginInstanceChild_h 1
9
10 #include "mozilla/plugins/PPluginInstanceChild.h"
11 #include "mozilla/plugins/PluginScriptableObjectChild.h"
12 #include "mozilla/plugins/StreamNotifyChild.h"
13 #include "mozilla/plugins/PPluginSurfaceChild.h"
14 #include "mozilla/ipc/CrossProcessMutex.h"
15 #include "nsClassHashtable.h"
16 #if defined(OS_WIN)
17 #include "mozilla/gfx/SharedDIBWin.h"
18 #elif defined(MOZ_WIDGET_COCOA)
19 #include "PluginUtilsOSX.h"
20 #include "mozilla/gfx/QuartzSupport.h"
21 #include "base/timer.h"
22
23 #endif
24
25 #include "npfunctions.h"
26 #include "nsAutoPtr.h"
27 #include "nsTArray.h"
28 #include "ChildAsyncCall.h"
29 #include "ChildTimer.h"
30 #include "nsRect.h"
31 #include "nsTHashtable.h"
32 #include "mozilla/PaintTracker.h"
33
34 #include <map>
35
36 #if (MOZ_WIDGET_GTK == 2)
37 #include "gtk2xtbin.h"
38 #endif
39
40 class gfxASurface;
41
42 namespace mozilla {
43
44 namespace layers {
45 struct RemoteImageData;
46 }
47
48 namespace plugins {
49
50 class PBrowserStreamChild;
51 class BrowserStreamChild;
52 class StreamNotifyChild;
53
54 class PluginInstanceChild : public PPluginInstanceChild
55 {
56 friend class BrowserStreamChild;
57 friend class PluginStreamChild;
58 friend class StreamNotifyChild;
59
60 #ifdef OS_WIN
61 friend LRESULT CALLBACK PluginWindowProc(HWND hWnd,
62 UINT message,
63 WPARAM wParam,
64 LPARAM lParam);
65 static LRESULT CALLBACK PluginWindowProcInternal(HWND hWnd,
66 UINT message,
67 WPARAM wParam,
68 LPARAM lParam);
69 #endif
70
71 protected:
72 virtual bool AnswerNPP_SetWindow(const NPRemoteWindow& window) MOZ_OVERRIDE;
73
74 virtual bool
75 AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(bool* wantsAllStreams, NPError* rv) MOZ_OVERRIDE;
76 virtual bool
77 AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(bool* needs, NPError* rv) MOZ_OVERRIDE;
78 virtual bool
79 AnswerNPP_GetValue_NPPVpluginScriptableNPObject(PPluginScriptableObjectChild** value,
80 NPError* result) MOZ_OVERRIDE;
81 virtual bool
82 AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(nsCString* aPlugId,
83 NPError* aResult) MOZ_OVERRIDE;
84 virtual bool
85 AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value, NPError* result) MOZ_OVERRIDE;
86
87 virtual bool
88 AnswerNPP_HandleEvent(const NPRemoteEvent& event, int16_t* handled) MOZ_OVERRIDE;
89 virtual bool
90 AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
91 Shmem& mem,
92 int16_t* handled,
93 Shmem* rtnmem) MOZ_OVERRIDE;
94 virtual bool
95 AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
96 const uint32_t& surface,
97 int16_t* handled) MOZ_OVERRIDE;
98
99 // Async rendering
100 virtual bool
101 RecvAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
102 const NPRemoteWindow& aWindow) MOZ_OVERRIDE;
103
104 virtual void
105 DoAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
106 const NPRemoteWindow& aWindow,
107 bool aIsAsync);
108
109 virtual PPluginSurfaceChild*
110 AllocPPluginSurfaceChild(const WindowsSharedMemoryHandle&,
111 const gfxIntSize&, const bool&) MOZ_OVERRIDE {
112 return new PPluginSurfaceChild();
113 }
114
115 virtual bool DeallocPPluginSurfaceChild(PPluginSurfaceChild* s) MOZ_OVERRIDE {
116 delete s;
117 return true;
118 }
119
120 virtual bool
121 AnswerPaint(const NPRemoteEvent& event, int16_t* handled) MOZ_OVERRIDE
122 {
123 PaintTracker pt;
124 return AnswerNPP_HandleEvent(event, handled);
125 }
126
127 virtual bool
128 RecvWindowPosChanged(const NPRemoteEvent& event) MOZ_OVERRIDE;
129
130 virtual bool
131 RecvContentsScaleFactorChanged(const double& aContentsScaleFactor) MOZ_OVERRIDE;
132
133 virtual bool
134 AnswerNPP_Destroy(NPError* result) MOZ_OVERRIDE;
135
136 virtual PPluginScriptableObjectChild*
137 AllocPPluginScriptableObjectChild() MOZ_OVERRIDE;
138
139 virtual bool
140 DeallocPPluginScriptableObjectChild(PPluginScriptableObjectChild* aObject) MOZ_OVERRIDE;
141
142 virtual bool
143 RecvPPluginScriptableObjectConstructor(PPluginScriptableObjectChild* aActor) MOZ_OVERRIDE;
144
145 virtual PBrowserStreamChild*
146 AllocPBrowserStreamChild(const nsCString& url,
147 const uint32_t& length,
148 const uint32_t& lastmodified,
149 PStreamNotifyChild* notifyData,
150 const nsCString& headers,
151 const nsCString& mimeType,
152 const bool& seekable,
153 NPError* rv,
154 uint16_t *stype) MOZ_OVERRIDE;
155
156 virtual bool
157 AnswerPBrowserStreamConstructor(
158 PBrowserStreamChild* aActor,
159 const nsCString& url,
160 const uint32_t& length,
161 const uint32_t& lastmodified,
162 PStreamNotifyChild* notifyData,
163 const nsCString& headers,
164 const nsCString& mimeType,
165 const bool& seekable,
166 NPError* rv,
167 uint16_t* stype) MOZ_OVERRIDE;
168
169 virtual bool
170 DeallocPBrowserStreamChild(PBrowserStreamChild* stream) MOZ_OVERRIDE;
171
172 virtual PPluginStreamChild*
173 AllocPPluginStreamChild(const nsCString& mimeType,
174 const nsCString& target,
175 NPError* result) MOZ_OVERRIDE;
176
177 virtual bool
178 DeallocPPluginStreamChild(PPluginStreamChild* stream) MOZ_OVERRIDE;
179
180 virtual PStreamNotifyChild*
181 AllocPStreamNotifyChild(const nsCString& url, const nsCString& target,
182 const bool& post, const nsCString& buffer,
183 const bool& file,
184 NPError* result) MOZ_OVERRIDE;
185
186 virtual bool
187 DeallocPStreamNotifyChild(PStreamNotifyChild* notifyData) MOZ_OVERRIDE;
188
189 virtual bool
190 AnswerSetPluginFocus() MOZ_OVERRIDE;
191
192 virtual bool
193 AnswerUpdateWindow() MOZ_OVERRIDE;
194
195 virtual bool
196 RecvNPP_DidComposite() MOZ_OVERRIDE;
197
198 #if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
199 bool CreateWindow(const NPRemoteWindow& aWindow);
200 void DeleteWindow();
201 #endif
202
203 public:
204 PluginInstanceChild(const NPPluginFuncs* aPluginIface);
205
206 virtual ~PluginInstanceChild();
207
208 bool Initialize();
209
210 NPP GetNPP()
211 {
212 return &mData;
213 }
214
215 NPError
216 NPN_GetValue(NPNVariable aVariable, void* aValue);
217
218 NPError
219 NPN_SetValue(NPPVariable aVariable, void* aValue);
220
221 PluginScriptableObjectChild*
222 GetActorForNPObject(NPObject* aObject);
223
224 NPError
225 NPN_NewStream(NPMIMEType aMIMEType, const char* aWindow,
226 NPStream** aStream);
227
228 void InvalidateRect(NPRect* aInvalidRect);
229
230 #ifdef MOZ_WIDGET_COCOA
231 void Invalidate();
232 #endif // definied(MOZ_WIDGET_COCOA)
233
234 uint32_t ScheduleTimer(uint32_t interval, bool repeat, TimerFunc func);
235 void UnscheduleTimer(uint32_t id);
236
237 void AsyncCall(PluginThreadCallback aFunc, void* aUserData);
238
239 int GetQuirks();
240
241 void NPN_URLRedirectResponse(void* notifyData, NPBool allow);
242
243 NPError NPN_InitAsyncSurface(NPSize *size, NPImageFormat format,
244 void *initData, NPAsyncSurface *surface);
245 NPError NPN_FinalizeAsyncSurface(NPAsyncSurface *surface);
246
247 void NPN_SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed);
248
249 void DoAsyncRedraw();
250 private:
251 friend class PluginModuleChild;
252
253 NPError
254 InternalGetNPObjectForValue(NPNVariable aValue,
255 NPObject** aObject);
256
257 bool IsAsyncDrawing();
258
259 NPError DeallocateAsyncBitmapSurface(NPAsyncSurface *aSurface);
260
261 virtual bool RecvUpdateBackground(const SurfaceDescriptor& aBackground,
262 const nsIntRect& aRect) MOZ_OVERRIDE;
263
264 virtual PPluginBackgroundDestroyerChild*
265 AllocPPluginBackgroundDestroyerChild() MOZ_OVERRIDE;
266
267 virtual bool
268 RecvPPluginBackgroundDestroyerConstructor(PPluginBackgroundDestroyerChild* aActor) MOZ_OVERRIDE;
269
270 virtual bool
271 DeallocPPluginBackgroundDestroyerChild(PPluginBackgroundDestroyerChild* aActor) MOZ_OVERRIDE;
272
273 #if defined(OS_WIN)
274 static bool RegisterWindowClass();
275 bool CreatePluginWindow();
276 void DestroyPluginWindow();
277 void ReparentPluginWindow(HWND hWndParent);
278 void SizePluginWindow(int width, int height);
279 int16_t WinlessHandleEvent(NPEvent& event);
280 void CreateWinlessPopupSurrogate();
281 void DestroyWinlessPopupSurrogate();
282 void InitPopupMenuHook();
283 void SetupFlashMsgThrottle();
284 void UnhookWinlessFlashThrottle();
285 void HookSetWindowLongPtr();
286 static inline bool SetWindowLongHookCheck(HWND hWnd,
287 int nIndex,
288 LONG_PTR newLong);
289 void FlashThrottleMessage(HWND, UINT, WPARAM, LPARAM, bool);
290 static LRESULT CALLBACK DummyWindowProc(HWND hWnd,
291 UINT message,
292 WPARAM wParam,
293 LPARAM lParam);
294 static LRESULT CALLBACK PluginWindowProc(HWND hWnd,
295 UINT message,
296 WPARAM wParam,
297 LPARAM lParam);
298 static BOOL WINAPI TrackPopupHookProc(HMENU hMenu,
299 UINT uFlags,
300 int x,
301 int y,
302 int nReserved,
303 HWND hWnd,
304 CONST RECT *prcRect);
305 static BOOL CALLBACK EnumThreadWindowsCallback(HWND hWnd,
306 LPARAM aParam);
307 static LRESULT CALLBACK WinlessHiddenFlashWndProc(HWND hWnd,
308 UINT message,
309 WPARAM wParam,
310 LPARAM lParam);
311 #ifdef _WIN64
312 static LONG_PTR WINAPI SetWindowLongPtrAHook(HWND hWnd,
313 int nIndex,
314 LONG_PTR newLong);
315 static LONG_PTR WINAPI SetWindowLongPtrWHook(HWND hWnd,
316 int nIndex,
317 LONG_PTR newLong);
318
319 #else
320 static LONG WINAPI SetWindowLongAHook(HWND hWnd,
321 int nIndex,
322 LONG newLong);
323 static LONG WINAPI SetWindowLongWHook(HWND hWnd,
324 int nIndex,
325 LONG newLong);
326 #endif
327
328 class FlashThrottleAsyncMsg : public ChildAsyncCall
329 {
330 public:
331 FlashThrottleAsyncMsg();
332 FlashThrottleAsyncMsg(PluginInstanceChild* aInst,
333 HWND aWnd, UINT aMsg,
334 WPARAM aWParam, LPARAM aLParam,
335 bool isWindowed)
336 : ChildAsyncCall(aInst, nullptr, nullptr),
337 mWnd(aWnd),
338 mMsg(aMsg),
339 mWParam(aWParam),
340 mLParam(aLParam),
341 mWindowed(isWindowed)
342 {}
343
344 void Run() MOZ_OVERRIDE;
345
346 WNDPROC GetProc();
347 HWND GetWnd() { return mWnd; }
348 UINT GetMsg() { return mMsg; }
349 WPARAM GetWParam() { return mWParam; }
350 LPARAM GetLParam() { return mLParam; }
351
352 private:
353 HWND mWnd;
354 UINT mMsg;
355 WPARAM mWParam;
356 LPARAM mLParam;
357 bool mWindowed;
358 };
359
360 #endif
361 const NPPluginFuncs* mPluginIface;
362 NPP_t mData;
363 NPWindow mWindow;
364 #if defined(XP_MACOSX)
365 double mContentsScaleFactor;
366 #endif
367 int16_t mDrawingModel;
368 NPAsyncSurface* mCurrentAsyncSurface;
369 struct AsyncBitmapData {
370 void *mRemotePtr;
371 Shmem mShmem;
372 };
373
374 static PLDHashOperator DeleteSurface(NPAsyncSurface* surf, nsAutoPtr<AsyncBitmapData> &data, void* userArg);
375 nsClassHashtable<nsPtrHashKey<NPAsyncSurface>, AsyncBitmapData> mAsyncBitmaps;
376 Shmem mRemoteImageDataShmem;
377 mozilla::layers::RemoteImageData *mRemoteImageData;
378 nsAutoPtr<CrossProcessMutex> mRemoteImageDataMutex;
379 mozilla::Mutex mAsyncInvalidateMutex;
380 CancelableTask *mAsyncInvalidateTask;
381
382 // Cached scriptable actors to avoid IPC churn
383 PluginScriptableObjectChild* mCachedWindowActor;
384 PluginScriptableObjectChild* mCachedElementActor;
385
386 #if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
387 NPSetWindowCallbackStruct mWsInfo;
388 #if (MOZ_WIDGET_GTK == 2)
389 bool mXEmbed;
390 XtClient mXtClient;
391 #endif
392 #elif defined(OS_WIN)
393 HWND mPluginWindowHWND;
394 WNDPROC mPluginWndProc;
395 HWND mPluginParentHWND;
396 int mNestedEventLevelDepth;
397 HWND mCachedWinlessPluginHWND;
398 HWND mWinlessPopupSurrogateHWND;
399 nsIntPoint mPluginSize;
400 WNDPROC mWinlessThrottleOldWndProc;
401 HWND mWinlessHiddenMsgHWND;
402 #endif
403
404 friend class ChildAsyncCall;
405
406 Mutex mAsyncCallMutex;
407 nsTArray<ChildAsyncCall*> mPendingAsyncCalls;
408 nsTArray<nsAutoPtr<ChildTimer> > mTimers;
409
410 /**
411 * During destruction we enumerate all remaining scriptable objects and
412 * invalidate/delete them. Enumeration can re-enter, so maintain a
413 * hash separate from PluginModuleChild.mObjectMap.
414 */
415 nsAutoPtr< nsTHashtable<DeletingObjectEntry> > mDeletingHash;
416
417 #if defined(OS_WIN)
418 private:
419 // Shared dib rendering management for windowless plugins.
420 bool SharedSurfaceSetWindow(const NPRemoteWindow& aWindow);
421 int16_t SharedSurfacePaint(NPEvent& evcopy);
422 void SharedSurfaceRelease();
423 bool AlphaExtractCacheSetup();
424 void AlphaExtractCacheRelease();
425 void UpdatePaintClipRect(RECT* aRect);
426
427 private:
428 enum {
429 RENDER_NATIVE,
430 RENDER_BACK_ONE,
431 RENDER_BACK_TWO
432 };
433 gfx::SharedDIBWin mSharedSurfaceDib;
434 struct {
435 uint16_t doublePass;
436 HDC hdc;
437 HBITMAP bmp;
438 } mAlphaExtract;
439 #endif // defined(OS_WIN)
440 #if defined(MOZ_WIDGET_COCOA)
441 private:
442 #if defined(__i386__)
443 NPEventModel mEventModel;
444 #endif
445 CGColorSpaceRef mShColorSpace;
446 CGContextRef mShContext;
447 mozilla::RefPtr<nsCARenderer> mCARenderer;
448 void *mCGLayer;
449
450 // Core Animation drawing model requires a refresh timer.
451 uint32_t mCARefreshTimer;
452
453 public:
454 const NPCocoaEvent* getCurrentEvent() {
455 return mCurrentEvent;
456 }
457
458 bool CGDraw(CGContextRef ref, nsIntRect aUpdateRect);
459
460 #if defined(__i386__)
461 NPEventModel EventModel() { return mEventModel; }
462 #endif
463
464 private:
465 const NPCocoaEvent *mCurrentEvent;
466 #endif
467
468 bool CanPaintOnBackground();
469
470 bool IsVisible() {
471 #ifdef XP_MACOSX
472 return mWindow.clipRect.top != mWindow.clipRect.bottom &&
473 mWindow.clipRect.left != mWindow.clipRect.right;
474 #else
475 return mWindow.clipRect.top != 0 ||
476 mWindow.clipRect.left != 0 ||
477 mWindow.clipRect.bottom != 0 ||
478 mWindow.clipRect.right != 0;
479 #endif
480 }
481
482 // ShowPluginFrame - in general does four things:
483 // 1) Create mCurrentSurface optimized for rendering to parent process
484 // 2) Updated mCurrentSurface to be a complete copy of mBackSurface
485 // 3) Draw the invalidated plugin area into mCurrentSurface
486 // 4) Send it to parent process.
487 bool ShowPluginFrame(void);
488
489 // If we can read back safely from mBackSurface, copy
490 // mSurfaceDifferenceRect from mBackSurface to mFrontSurface.
491 // @return Whether the back surface could be read.
492 bool ReadbackDifferenceRect(const nsIntRect& rect);
493
494 // Post ShowPluginFrame task
495 void AsyncShowPluginFrame(void);
496
497 // In the PaintRect functions, aSurface is the size of the full plugin
498 // window. Each PaintRect function renders into the subrectangle aRect of
499 // aSurface (possibly more if we're working around a Flash bug).
500
501 // Paint plugin content rectangle to surface with bg color filling
502 void PaintRectToSurface(const nsIntRect& aRect,
503 gfxASurface* aSurface,
504 const gfxRGBA& aColor);
505
506 // Render plugin content to surface using
507 // white/black image alpha extraction algorithm
508 void PaintRectWithAlphaExtraction(const nsIntRect& aRect,
509 gfxASurface* aSurface);
510
511 // Call plugin NPAPI function to render plugin content to surface
512 // @param - aSurface - should be compatible with current platform plugin rendering
513 // @return - FALSE if plugin not painted to surface
514 void PaintRectToPlatformSurface(const nsIntRect& aRect,
515 gfxASurface* aSurface);
516
517 // Update NPWindow platform attributes and call plugin "setwindow"
518 // @param - aForceSetWindow - call setwindow even if platform attributes are the same
519 void UpdateWindowAttributes(bool aForceSetWindow = false);
520
521 // Create optimized mCurrentSurface for parent process rendering
522 // @return FALSE if optimized surface not created
523 bool CreateOptSurface(void);
524
525 // Create mHelperSurface if mCurrentSurface non compatible with plugins
526 // @return TRUE if helper surface created successfully, or not needed
527 bool MaybeCreatePlatformHelperSurface(void);
528
529 // Make sure that we have surface for rendering
530 bool EnsureCurrentBuffer(void);
531
532 // Helper function for delayed InvalidateRect call
533 // non null mCurrentInvalidateTask will call this function
534 void InvalidateRectDelayed(void);
535
536 // Clear mCurrentSurface/mCurrentSurfaceActor/mHelperSurface
537 void ClearCurrentSurface();
538
539 // Swap mCurrentSurface/mBackSurface and their associated actors
540 void SwapSurfaces();
541
542 // Clear all surfaces in response to NPP_Destroy
543 void ClearAllSurfaces();
544
545 // Set as true when SetupLayer called
546 // and go with different path in InvalidateRect function
547 bool mLayersRendering;
548
549 // Current surface available for rendering
550 nsRefPtr<gfxASurface> mCurrentSurface;
551
552 // Back surface, just keeping reference to
553 // surface which is on ParentProcess side
554 nsRefPtr<gfxASurface> mBackSurface;
555
556 #ifdef XP_MACOSX
557 // Current IOSurface available for rendering
558 // We can't use thebes gfxASurface like other platforms.
559 PluginUtilsOSX::nsDoubleBufferCARenderer mDoubleBufferCARenderer;
560 #endif
561
562 // (Not to be confused with mBackSurface). This is a recent copy
563 // of the opaque pixels under our object frame, if
564 // |mIsTransparent|. We ask the plugin render directly onto a
565 // copy of the background pixels if available, and fall back on
566 // alpha recovery otherwise.
567 nsRefPtr<gfxASurface> mBackground;
568
569 #ifdef XP_WIN
570 // These actors mirror mCurrentSurface/mBackSurface
571 PPluginSurfaceChild* mCurrentSurfaceActor;
572 PPluginSurfaceChild* mBackSurfaceActor;
573 #endif
574
575 // Accumulated invalidate rect, while back buffer is not accessible,
576 // in plugin coordinates.
577 nsIntRect mAccumulatedInvalidRect;
578
579 // Plugin only call SetTransparent
580 // and does not remember their transparent state
581 // and p->getvalue return always false
582 bool mIsTransparent;
583
584 // Surface type optimized of parent process
585 gfxSurfaceType mSurfaceType;
586
587 // Keep InvalidateRect task pointer to be able Cancel it on Destroy
588 CancelableTask *mCurrentInvalidateTask;
589
590 // Keep AsyncSetWindow task pointer to be able to Cancel it on Destroy
591 CancelableTask *mCurrentAsyncSetWindowTask;
592
593 // True while plugin-child in plugin call
594 // Use to prevent plugin paint re-enter
595 bool mPendingPluginCall;
596
597 // On some platforms, plugins may not support rendering to a surface with
598 // alpha, or not support rendering to an image surface.
599 // In those cases we need to draw to a temporary platform surface; we cache
600 // that surface here.
601 nsRefPtr<gfxASurface> mHelperSurface;
602
603 // true when plugin does not support painting to ARGB32
604 // surface this is false if plugin supports
605 // NPPVpluginTransparentAlphaBool (which is not part of
606 // NPAPI yet)
607 bool mDoAlphaExtraction;
608
609 // true when the plugin has painted at least once. We use this to ensure
610 // that we ask a plugin to paint at least once even if it's invisible;
611 // some plugin (instances) rely on this in order to work properly.
612 bool mHasPainted;
613
614 // Cached rectangle rendered to previous surface(mBackSurface)
615 // Used for reading back to current surface and syncing data,
616 // in plugin coordinates.
617 nsIntRect mSurfaceDifferenceRect;
618 };
619
620 } // namespace plugins
621 } // namespace mozilla
622
623 #endif // ifndef dom_plugins_PluginInstanceChild_h

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial