The Tor Browser / file comparison

comparison: dom/plugins/ipc/PluginModuleChild.cpp

dom/plugins/ipc/PluginModuleChild.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:d3493a328777
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* vim: set 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 #ifdef MOZ_WIDGET_QT
8 #include <unistd.h> // for _exit()
9 #include <QtCore/QTimer>
10 #include "nsQAppInstance.h"
11 #include "NestedLoopTimer.h"
12 #endif
13
14 #include "mozilla/plugins/PluginModuleChild.h"
15
16 /* This must occur *after* plugins/PluginModuleChild.h to avoid typedefs conflicts. */
17 #include "mozilla/ArrayUtils.h"
18
19 #include "mozilla/ipc/MessageChannel.h"
20
21 #ifdef MOZ_WIDGET_GTK
22 #include <gtk/gtk.h>
23 #if (MOZ_WIDGET_GTK == 3)
24 #include <gtk/gtkx.h>
25 #endif
26 #endif
27
28 #include "nsIFile.h"
29
30 #include "pratom.h"
31 #include "nsDebug.h"
32 #include "nsCOMPtr.h"
33 #include "nsPluginsDir.h"
34 #include "nsXULAppAPI.h"
35
36 #ifdef MOZ_X11
37 # include "mozilla/X11Util.h"
38 #endif
39 #include "mozilla/plugins/PluginInstanceChild.h"
40 #include "mozilla/plugins/StreamNotifyChild.h"
41 #include "mozilla/plugins/BrowserStreamChild.h"
42 #include "mozilla/plugins/PluginStreamChild.h"
43 #include "PluginIdentifierChild.h"
44 #include "mozilla/dom/CrashReporterChild.h"
45
46 #include "nsNPAPIPlugin.h"
47
48 #ifdef XP_WIN
49 #include "COMMessageFilter.h"
50 #include "nsWindowsDllInterceptor.h"
51 #include "mozilla/widget/AudioSession.h"
52 #endif
53
54 #ifdef MOZ_WIDGET_COCOA
55 #include "PluginInterposeOSX.h"
56 #include "PluginUtilsOSX.h"
57 #endif
58
59 #include "GeckoProfiler.h"
60
61 using namespace mozilla;
62 using namespace mozilla::plugins;
63 using mozilla::dom::CrashReporterChild;
64 using mozilla::dom::PCrashReporterChild;
65
66 #if defined(XP_WIN)
67 const wchar_t * kFlashFullscreenClass = L"ShockwaveFlashFullScreen";
68 const wchar_t * kMozillaWindowClass = L"MozillaWindowClass";
69 #endif
70
71 namespace {
72 PluginModuleChild* gInstance = nullptr;
73 }
74
75 #ifdef MOZ_WIDGET_QT
76 typedef void (*_gtk_init_fn)(int argc, char **argv);
77 static _gtk_init_fn s_gtk_init = nullptr;
78 static PRLibrary *sGtkLib = nullptr;
79 #endif
80
81 #ifdef XP_WIN
82 // Used with fix for flash fullscreen window loosing focus.
83 static bool gDelayFlashFocusReplyUntilEval = false;
84 // Used to fix GetWindowInfo problems with internal flash settings dialogs
85 static WindowsDllInterceptor sUser32Intercept;
86 typedef BOOL (WINAPI *GetWindowInfoPtr)(HWND hwnd, PWINDOWINFO pwi);
87 static GetWindowInfoPtr sGetWindowInfoPtrStub = nullptr;
88 static HWND sBrowserHwnd = nullptr;
89 #endif
90
91 PluginModuleChild::PluginModuleChild()
92 : mLibrary(0)
93 , mPluginFilename("")
94 , mQuirks(QUIRKS_NOT_INITIALIZED)
95 , mShutdownFunc(0)
96 , mInitializeFunc(0)
97 #if defined(OS_WIN) || defined(OS_MACOSX)
98 , mGetEntryPointsFunc(0)
99 #elif defined(MOZ_WIDGET_GTK)
100 , mNestedLoopTimerId(0)
101 #elif defined(MOZ_WIDGET_QT)
102 , mNestedLoopTimerObject(0)
103 #endif
104 #ifdef OS_WIN
105 , mNestedEventHook(nullptr)
106 , mGlobalCallWndProcHook(nullptr)
107 #endif
108 {
109 NS_ASSERTION(!gInstance, "Something terribly wrong here!");
110 memset(&mFunctions, 0, sizeof(mFunctions));
111 memset(&mSavedData, 0, sizeof(mSavedData));
112 gInstance = this;
113 mUserAgent.SetIsVoid(true);
114 #ifdef XP_MACOSX
115 mac_plugin_interposing::child::SetUpCocoaInterposing();
116 #endif
117 }
118
119 PluginModuleChild::~PluginModuleChild()
120 {
121 NS_ASSERTION(gInstance == this, "Something terribly wrong here!");
122
123 // We don't unload the plugin library in case it uses atexit handlers or
124 // other similar hooks.
125
126 DeinitGraphics();
127
128 gInstance = nullptr;
129 }
130
131 // static
132 PluginModuleChild*
133 PluginModuleChild::current()
134 {
135 NS_ASSERTION(gInstance, "Null instance!");
136 return gInstance;
137 }
138
139 bool
140 PluginModuleChild::Init(const std::string& aPluginFilename,
141 base::ProcessHandle aParentProcessHandle,
142 MessageLoop* aIOLoop,
143 IPC::Channel* aChannel)
144 {
145 PLUGIN_LOG_DEBUG_METHOD;
146
147 GetIPCChannel()->SetAbortOnError(true);
148
149 // Request Windows message deferral behavior on our channel. This
150 // applies to the top level and all sub plugin protocols since they
151 // all share the same channel.
152 GetIPCChannel()->SetChannelFlags(MessageChannel::REQUIRE_DEFERRED_MESSAGE_PROTECTION);
153
154 #ifdef XP_WIN
155 COMMessageFilter::Initialize(this);
156 #endif
157
158 NS_ASSERTION(aChannel, "need a channel");
159
160 if (!InitGraphics())
161 return false;
162
163 mPluginFilename = aPluginFilename.c_str();
164 nsCOMPtr<nsIFile> localFile;
165 NS_NewLocalFile(NS_ConvertUTF8toUTF16(mPluginFilename),
166 true,
167 getter_AddRefs(localFile));
168
169 bool exists;
170 localFile->Exists(&exists);
171 NS_ASSERTION(exists, "plugin file ain't there");
172
173 nsPluginFile pluginFile(localFile);
174
175 #if defined(MOZ_X11) || defined(OS_MACOSX)
176 nsPluginInfo info = nsPluginInfo();
177 if (NS_FAILED(pluginFile.GetPluginInfo(info, &mLibrary))) {
178 return false;
179 }
180
181 #if defined(MOZ_X11)
182 NS_NAMED_LITERAL_CSTRING(flash10Head, "Shockwave Flash 10.");
183 if (StringBeginsWith(nsDependentCString(info.fDescription), flash10Head)) {
184 AddQuirk(QUIRK_FLASH_EXPOSE_COORD_TRANSLATION);
185 }
186 #else // defined(OS_MACOSX)
187 mozilla::plugins::PluginUtilsOSX::SetProcessName(info.fName);
188 #endif
189
190 pluginFile.FreePluginInfo(info);
191
192 if (!mLibrary)
193 #endif
194 {
195 nsresult rv = pluginFile.LoadPlugin(&mLibrary);
196 if (NS_FAILED(rv))
197 return false;
198 }
199 NS_ASSERTION(mLibrary, "couldn't open shared object");
200
201 if (!Open(aChannel, aParentProcessHandle, aIOLoop))
202 return false;
203
204 memset((void*) &mFunctions, 0, sizeof(mFunctions));
205 mFunctions.size = sizeof(mFunctions);
206 mFunctions.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
207
208 // TODO: use PluginPRLibrary here
209
210 #if defined(OS_LINUX) || defined(OS_BSD)
211 mShutdownFunc =
212 (NP_PLUGINSHUTDOWN) PR_FindFunctionSymbol(mLibrary, "NP_Shutdown");
213
214 // create the new plugin handler
215
216 mInitializeFunc =
217 (NP_PLUGINUNIXINIT) PR_FindFunctionSymbol(mLibrary, "NP_Initialize");
218 NS_ASSERTION(mInitializeFunc, "couldn't find NP_Initialize()");
219
220 #elif defined(OS_WIN) || defined(OS_MACOSX)
221 mShutdownFunc =
222 (NP_PLUGINSHUTDOWN)PR_FindFunctionSymbol(mLibrary, "NP_Shutdown");
223
224 mGetEntryPointsFunc =
225 (NP_GETENTRYPOINTS)PR_FindSymbol(mLibrary, "NP_GetEntryPoints");
226 NS_ENSURE_TRUE(mGetEntryPointsFunc, false);
227
228 mInitializeFunc =
229 (NP_PLUGININIT)PR_FindFunctionSymbol(mLibrary, "NP_Initialize");
230 NS_ENSURE_TRUE(mInitializeFunc, false);
231 #else
232
233 # error Please copy the initialization code from nsNPAPIPlugin.cpp
234
235 #endif
236
237 return true;
238 }
239
240 #if defined(MOZ_WIDGET_GTK)
241 typedef void (*GObjectDisposeFn)(GObject*);
242 typedef gboolean (*GtkWidgetScrollEventFn)(GtkWidget*, GdkEventScroll*);
243 typedef void (*GtkPlugEmbeddedFn)(GtkPlug*);
244
245 static GObjectDisposeFn real_gtk_plug_dispose;
246 static GtkPlugEmbeddedFn real_gtk_plug_embedded;
247
248 static void
249 undo_bogus_unref(gpointer data, GObject* object, gboolean is_last_ref) {
250 if (!is_last_ref) // recursion in g_object_ref
251 return;
252
253 g_object_ref(object);
254 }
255
256 static void
257 wrap_gtk_plug_dispose(GObject* object) {
258 // Work around Flash Player bug described in bug 538914.
259 //
260 // This function is called during gtk_widget_destroy and/or before
261 // the object's last reference is removed. A reference to the
262 // object is held during the call so the ref count should not drop
263 // to zero. However, Flash Player tries to destroy the GtkPlug
264 // using g_object_unref instead of gtk_widget_destroy. The
265 // reference that Flash is removing actually belongs to the
266 // GtkPlug. During real_gtk_plug_dispose, the GtkPlug removes its
267 // reference.
268 //
269 // A toggle ref is added to prevent premature deletion of the object
270 // caused by Flash Player's extra unref, and to detect when there are
271 // unexpectedly no other references.
272 g_object_add_toggle_ref(object, undo_bogus_unref, nullptr);
273 (*real_gtk_plug_dispose)(object);
274 g_object_remove_toggle_ref(object, undo_bogus_unref, nullptr);
275 }
276
277 static gboolean
278 gtk_plug_scroll_event(GtkWidget *widget, GdkEventScroll *gdk_event)
279 {
280 if (!gtk_widget_is_toplevel(widget)) // in same process as its GtkSocket
281 return FALSE; // event not handled; propagate to GtkSocket
282
283 GdkWindow* socket_window = gtk_plug_get_socket_window(GTK_PLUG(widget));
284 if (!socket_window)
285 return FALSE;
286
287 // Propagate the event to the embedder.
288 GdkScreen* screen = gdk_window_get_screen(socket_window);
289 GdkWindow* plug_window = gtk_widget_get_window(widget);
290 GdkWindow* event_window = gdk_event->window;
291 gint x = gdk_event->x;
292 gint y = gdk_event->y;
293 unsigned int button;
294 unsigned int button_mask = 0;
295 XEvent xevent;
296 Display* dpy = GDK_WINDOW_XDISPLAY(socket_window);
297
298 /* Translate the event coordinates to the plug window,
299 * which should be aligned with the socket window.
300 */
301 while (event_window != plug_window)
302 {
303 gint dx, dy;
304
305 gdk_window_get_position(event_window, &dx, &dy);
306 x += dx;
307 y += dy;
308
309 event_window = gdk_window_get_parent(event_window);
310 if (!event_window)
311 return FALSE;
312 }
313
314 switch (gdk_event->direction) {
315 case GDK_SCROLL_UP:
316 button = 4;
317 button_mask = Button4Mask;
318 break;
319 case GDK_SCROLL_DOWN:
320 button = 5;
321 button_mask = Button5Mask;
322 break;
323 case GDK_SCROLL_LEFT:
324 button = 6;
325 break;
326 case GDK_SCROLL_RIGHT:
327 button = 7;
328 break;
329 default:
330 return FALSE; // unknown GdkScrollDirection
331 }
332
333 memset(&xevent, 0, sizeof(xevent));
334 xevent.xbutton.type = ButtonPress;
335 xevent.xbutton.window = gdk_x11_window_get_xid(socket_window);
336 xevent.xbutton.root = gdk_x11_window_get_xid(gdk_screen_get_root_window(screen));
337 xevent.xbutton.subwindow = gdk_x11_window_get_xid(plug_window);
338 xevent.xbutton.time = gdk_event->time;
339 xevent.xbutton.x = x;
340 xevent.xbutton.y = y;
341 xevent.xbutton.x_root = gdk_event->x_root;
342 xevent.xbutton.y_root = gdk_event->y_root;
343 xevent.xbutton.state = gdk_event->state;
344 xevent.xbutton.button = button;
345 xevent.xbutton.same_screen = True;
346
347 gdk_error_trap_push();
348
349 XSendEvent(dpy, xevent.xbutton.window,
350 True, ButtonPressMask, &xevent);
351
352 xevent.xbutton.type = ButtonRelease;
353 xevent.xbutton.state |= button_mask;
354 XSendEvent(dpy, xevent.xbutton.window,
355 True, ButtonReleaseMask, &xevent);
356
357 gdk_display_sync(gdk_screen_get_display(screen));
358 gdk_error_trap_pop();
359
360 return TRUE; // event handled
361 }
362
363 static void
364 wrap_gtk_plug_embedded(GtkPlug* plug) {
365 GdkWindow* socket_window = gtk_plug_get_socket_window(plug);
366 if (socket_window) {
367 if (gtk_check_version(2,18,7) != nullptr // older
368 && g_object_get_data(G_OBJECT(socket_window),
369 "moz-existed-before-set-window")) {
370 // Add missing reference for
371 // https://bugzilla.gnome.org/show_bug.cgi?id=607061
372 g_object_ref(socket_window);
373 }
374
375 // Ensure the window exists to make this GtkPlug behave like an
376 // in-process GtkPlug for Flash Player. (Bugs 561308 and 539138).
377 gtk_widget_realize(GTK_WIDGET(plug));
378 }
379
380 if (*real_gtk_plug_embedded) {
381 (*real_gtk_plug_embedded)(plug);
382 }
383 }
384
385 //
386 // The next four constants are knobs that can be tuned. They trade
387 // off potential UI lag from delayed event processing with CPU time.
388 //
389 static const gint kNestedLoopDetectorPriority = G_PRIORITY_HIGH_IDLE;
390 // 90ms so that we can hopefully break livelocks before the user
391 // notices UI lag (100ms)
392 static const guint kNestedLoopDetectorIntervalMs = 90;
393
394 static const gint kBrowserEventPriority = G_PRIORITY_HIGH_IDLE;
395 static const guint kBrowserEventIntervalMs = 10;
396
397 // static
398 gboolean
399 PluginModuleChild::DetectNestedEventLoop(gpointer data)
400 {
401 PluginModuleChild* pmc = static_cast<PluginModuleChild*>(data);
402
403 NS_ABORT_IF_FALSE(0 != pmc->mNestedLoopTimerId,
404 "callback after descheduling");
405 NS_ABORT_IF_FALSE(pmc->mTopLoopDepth < g_main_depth(),
406 "not canceled before returning to main event loop!");
407
408 PLUGIN_LOG_DEBUG(("Detected nested glib event loop"));
409
410 // just detected a nested loop; start a timer that will
411 // periodically rpc-call back into the browser and process some
412 // events
413 pmc->mNestedLoopTimerId =
414 g_timeout_add_full(kBrowserEventPriority,
415 kBrowserEventIntervalMs,
416 PluginModuleChild::ProcessBrowserEvents,
417 data,
418 nullptr);
419 // cancel the nested-loop detection timer
420 return FALSE;
421 }
422
423 // static
424 gboolean
425 PluginModuleChild::ProcessBrowserEvents(gpointer data)
426 {
427 PluginModuleChild* pmc = static_cast<PluginModuleChild*>(data);
428
429 NS_ABORT_IF_FALSE(pmc->mTopLoopDepth < g_main_depth(),
430 "not canceled before returning to main event loop!");
431
432 pmc->CallProcessSomeEvents();
433
434 return TRUE;
435 }
436
437 void
438 PluginModuleChild::EnteredCxxStack()
439 {
440 NS_ABORT_IF_FALSE(0 == mNestedLoopTimerId,
441 "previous timer not descheduled");
442
443 mNestedLoopTimerId =
444 g_timeout_add_full(kNestedLoopDetectorPriority,
445 kNestedLoopDetectorIntervalMs,
446 PluginModuleChild::DetectNestedEventLoop,
447 this,
448 nullptr);
449
450 #ifdef DEBUG
451 mTopLoopDepth = g_main_depth();
452 #endif
453 }
454
455 void
456 PluginModuleChild::ExitedCxxStack()
457 {
458 NS_ABORT_IF_FALSE(0 < mNestedLoopTimerId,
459 "nested loop timeout not scheduled");
460
461 g_source_remove(mNestedLoopTimerId);
462 mNestedLoopTimerId = 0;
463 }
464 #elif defined (MOZ_WIDGET_QT)
465
466 void
467 PluginModuleChild::EnteredCxxStack()
468 {
469 NS_ABORT_IF_FALSE(mNestedLoopTimerObject == nullptr,
470 "previous timer not descheduled");
471 mNestedLoopTimerObject = new NestedLoopTimer(this);
472 QTimer::singleShot(kNestedLoopDetectorIntervalMs,
473 mNestedLoopTimerObject, SLOT(timeOut()));
474 }
475
476 void
477 PluginModuleChild::ExitedCxxStack()
478 {
479 NS_ABORT_IF_FALSE(mNestedLoopTimerObject != nullptr,
480 "nested loop timeout not scheduled");
481 delete mNestedLoopTimerObject;
482 mNestedLoopTimerObject = nullptr;
483 }
484
485 #endif
486
487 bool
488 PluginModuleChild::RecvSetParentHangTimeout(const uint32_t& aSeconds)
489 {
490 #ifdef XP_WIN
491 SetReplyTimeoutMs(((aSeconds > 0) ? (1000 * aSeconds) : 0));
492 #endif
493 return true;
494 }
495
496 bool
497 PluginModuleChild::ShouldContinueFromReplyTimeout()
498 {
499 #ifdef XP_WIN
500 NS_RUNTIMEABORT("terminating child process");
501 #endif
502 return true;
503 }
504
505 bool
506 PluginModuleChild::InitGraphics()
507 {
508 #if defined(MOZ_WIDGET_GTK)
509 // Work around plugins that don't interact well with GDK
510 // client-side windows.
511 PR_SetEnv("GDK_NATIVE_WINDOWS=1");
512
513 gtk_init(0, 0);
514
515 // GtkPlug is a static class so will leak anyway but this ref makes sure.
516 gpointer gtk_plug_class = g_type_class_ref(GTK_TYPE_PLUG);
517
518 // The dispose method is a good place to hook into the destruction process
519 // because the reference count should be 1 the last time dispose is
520 // called. (Toggle references wouldn't detect if the reference count
521 // might be higher.)
522 GObjectDisposeFn* dispose = &G_OBJECT_CLASS(gtk_plug_class)->dispose;
523 NS_ABORT_IF_FALSE(*dispose != wrap_gtk_plug_dispose,
524 "InitGraphics called twice");
525 real_gtk_plug_dispose = *dispose;
526 *dispose = wrap_gtk_plug_dispose;
527
528 // If we ever stop setting GDK_NATIVE_WINDOWS, we'll also need to
529 // gtk_widget_add_events GDK_SCROLL_MASK or GDK client-side windows will
530 // not tell us about the scroll events that it intercepts. With native
531 // windows, this is called when GDK intercepts the events; if GDK doesn't
532 // intercept the events, then the X server will instead send them directly
533 // to an ancestor (embedder) window.
534 GtkWidgetScrollEventFn* scroll_event =
535 &GTK_WIDGET_CLASS(gtk_plug_class)->scroll_event;
536 if (!*scroll_event) {
537 *scroll_event = gtk_plug_scroll_event;
538 }
539
540 GtkPlugEmbeddedFn* embedded = &GTK_PLUG_CLASS(gtk_plug_class)->embedded;
541 real_gtk_plug_embedded = *embedded;
542 *embedded = wrap_gtk_plug_embedded;
543
544 #elif defined(MOZ_WIDGET_QT)
545 nsQAppInstance::AddRef();
546 // Work around plugins that don't interact well without gtk initialized
547 // see bug 566845
548 #if defined(MOZ_X11)
549 if (!sGtkLib)
550 sGtkLib = PR_LoadLibrary("libgtk-x11-2.0.so.0");
551 #endif
552 if (sGtkLib) {
553 s_gtk_init = (_gtk_init_fn)PR_FindFunctionSymbol(sGtkLib, "gtk_init");
554 if (s_gtk_init)
555 s_gtk_init(0, 0);
556 }
557 #else
558 // may not be necessary on all platforms
559 #endif
560 #ifdef MOZ_X11
561 // Do this after initializing GDK, or GDK will install its own handler.
562 XRE_InstallX11ErrorHandler();
563 #endif
564 return true;
565 }
566
567 void
568 PluginModuleChild::DeinitGraphics()
569 {
570 #ifdef MOZ_WIDGET_QT
571 nsQAppInstance::Release();
572 if (sGtkLib) {
573 PR_UnloadLibrary(sGtkLib);
574 sGtkLib = nullptr;
575 s_gtk_init = nullptr;
576 }
577 #endif
578
579 #if defined(MOZ_X11) && defined(NS_FREE_PERMANENT_DATA)
580 // We free some data off of XDisplay close hooks, ensure they're
581 // run. Closing the display is pretty scary, so we only do it to
582 // silence leak checkers.
583 XCloseDisplay(DefaultXDisplay());
584 #endif
585 }
586
587 bool
588 PluginModuleChild::AnswerNP_Shutdown(NPError *rv)
589 {
590 AssertPluginThread();
591
592 #if defined XP_WIN
593 mozilla::widget::StopAudioSession();
594 #endif
595
596 // the PluginModuleParent shuts down this process after this interrupt
597 // call pops off its stack
598
599 *rv = mShutdownFunc ? mShutdownFunc() : NPERR_NO_ERROR;
600
601 // weakly guard against re-entry after NP_Shutdown
602 memset(&mFunctions, 0, sizeof(mFunctions));
603
604 #ifdef OS_WIN
605 ResetEventHooks();
606 #endif
607
608 GetIPCChannel()->SetAbortOnError(false);
609
610 return true;
611 }
612
613 bool
614 PluginModuleChild::AnswerOptionalFunctionsSupported(bool *aURLRedirectNotify,
615 bool *aClearSiteData,
616 bool *aGetSitesWithData)
617 {
618 *aURLRedirectNotify = !!mFunctions.urlredirectnotify;
619 *aClearSiteData = !!mFunctions.clearsitedata;
620 *aGetSitesWithData = !!mFunctions.getsiteswithdata;
621 return true;
622 }
623
624 bool
625 PluginModuleChild::AnswerNPP_ClearSiteData(const nsCString& aSite,
626 const uint64_t& aFlags,
627 const uint64_t& aMaxAge,
628 NPError* aResult)
629 {
630 *aResult =
631 mFunctions.clearsitedata(NullableStringGet(aSite), aFlags, aMaxAge);
632 return true;
633 }
634
635 bool
636 PluginModuleChild::AnswerNPP_GetSitesWithData(InfallibleTArray<nsCString>* aResult)
637 {
638 char** result = mFunctions.getsiteswithdata();
639 if (!result)
640 return true;
641
642 char** iterator = result;
643 while (*iterator) {
644 aResult->AppendElement(*iterator);
645 NS_Free(*iterator);
646 ++iterator;
647 }
648 NS_Free(result);
649
650 return true;
651 }
652
653 bool
654 PluginModuleChild::RecvSetAudioSessionData(const nsID& aId,
655 const nsString& aDisplayName,
656 const nsString& aIconPath)
657 {
658 #if !defined XP_WIN
659 NS_RUNTIMEABORT("Not Reached!");
660 return false;
661 #else
662 nsresult rv = mozilla::widget::RecvAudioSessionData(aId, aDisplayName, aIconPath);
663 NS_ENSURE_SUCCESS(rv, true); // Bail early if this fails
664
665 // Ignore failures here; we can't really do anything about them
666 mozilla::widget::StartAudioSession();
667 return true;
668 #endif
669 }
670
671 void
672 PluginModuleChild::QuickExit()
673 {
674 NS_WARNING("plugin process _exit()ing");
675 _exit(0);
676 }
677
678 PCrashReporterChild*
679 PluginModuleChild::AllocPCrashReporterChild(mozilla::dom::NativeThreadId* id,
680 uint32_t* processType)
681 {
682 return new CrashReporterChild();
683 }
684
685 bool
686 PluginModuleChild::DeallocPCrashReporterChild(PCrashReporterChild* actor)
687 {
688 delete actor;
689 return true;
690 }
691
692 bool
693 PluginModuleChild::AnswerPCrashReporterConstructor(
694 PCrashReporterChild* actor,
695 mozilla::dom::NativeThreadId* id,
696 uint32_t* processType)
697 {
698 #ifdef MOZ_CRASHREPORTER
699 *id = CrashReporter::CurrentThreadId();
700 *processType = XRE_GetProcessType();
701 #endif
702 return true;
703 }
704
705 void
706 PluginModuleChild::ActorDestroy(ActorDestroyReason why)
707 {
708 if (AbnormalShutdown == why) {
709 NS_WARNING("shutting down early because of crash!");
710 QuickExit();
711 }
712
713 // doesn't matter why we're being destroyed; it's up to us to
714 // initiate (clean) shutdown
715 XRE_ShutdownChildProcess();
716 }
717
718 void
719 PluginModuleChild::CleanUp()
720 {
721 }
722
723 const char*
724 PluginModuleChild::GetUserAgent()
725 {
726 if (mUserAgent.IsVoid() && !CallNPN_UserAgent(&mUserAgent))
727 return nullptr;
728
729 return NullableStringGet(mUserAgent);
730 }
731
732 bool
733 PluginModuleChild::RegisterActorForNPObject(NPObject* aObject,
734 PluginScriptableObjectChild* aActor)
735 {
736 AssertPluginThread();
737 NS_ASSERTION(aObject && aActor, "Null pointer!");
738
739 NPObjectData* d = mObjectMap.GetEntry(aObject);
740 if (!d) {
741 NS_ERROR("NPObject not in object table");
742 return false;
743 }
744
745 d->actor = aActor;
746 return true;
747 }
748
749 void
750 PluginModuleChild::UnregisterActorForNPObject(NPObject* aObject)
751 {
752 AssertPluginThread();
753 NS_ASSERTION(aObject, "Null pointer!");
754
755 NPObjectData* d = mObjectMap.GetEntry(aObject);
756 NS_ASSERTION(d, "NPObject not in object table");
757 if (d) {
758 d->actor = nullptr;
759 }
760 }
761
762 PluginScriptableObjectChild*
763 PluginModuleChild::GetActorForNPObject(NPObject* aObject)
764 {
765 AssertPluginThread();
766 NS_ASSERTION(aObject, "Null pointer!");
767
768 NPObjectData* d = mObjectMap.GetEntry(aObject);
769 if (!d) {
770 NS_ERROR("Plugin using object not created with NPN_CreateObject?");
771 return nullptr;
772 }
773
774 return d->actor;
775 }
776
777 #ifdef DEBUG
778 bool
779 PluginModuleChild::NPObjectIsRegistered(NPObject* aObject)
780 {
781 return !!mObjectMap.GetEntry(aObject);
782 }
783 #endif
784
785 //-----------------------------------------------------------------------------
786 // FIXME/cjones: just getting this out of the way for the moment ...
787
788 namespace mozilla {
789 namespace plugins {
790 namespace child {
791
792 static NPError
793 _requestread(NPStream *pstream, NPByteRange *rangeList);
794
795 static NPError
796 _geturlnotify(NPP aNPP, const char* relativeURL, const char* target,
797 void* notifyData);
798
799 static NPError
800 _getvalue(NPP aNPP, NPNVariable variable, void *r_value);
801
802 static NPError
803 _setvalue(NPP aNPP, NPPVariable variable, void *r_value);
804
805 static NPError
806 _geturl(NPP aNPP, const char* relativeURL, const char* target);
807
808 static NPError
809 _posturlnotify(NPP aNPP, const char* relativeURL, const char *target,
810 uint32_t len, const char *buf, NPBool file, void* notifyData);
811
812 static NPError
813 _posturl(NPP aNPP, const char* relativeURL, const char *target, uint32_t len,
814 const char *buf, NPBool file);
815
816 static NPError
817 _newstream(NPP aNPP, NPMIMEType type, const char* window, NPStream** pstream);
818
819 static int32_t
820 _write(NPP aNPP, NPStream *pstream, int32_t len, void *buffer);
821
822 static NPError
823 _destroystream(NPP aNPP, NPStream *pstream, NPError reason);
824
825 static void
826 _status(NPP aNPP, const char *message);
827
828 static void
829 _memfree (void *ptr);
830
831 static uint32_t
832 _memflush(uint32_t size);
833
834 static void
835 _reloadplugins(NPBool reloadPages);
836
837 static void
838 _invalidaterect(NPP aNPP, NPRect *invalidRect);
839
840 static void
841 _invalidateregion(NPP aNPP, NPRegion invalidRegion);
842
843 static void
844 _forceredraw(NPP aNPP);
845
846 static const char*
847 _useragent(NPP aNPP);
848
849 static void*
850 _memalloc (uint32_t size);
851
852 // Deprecated entry points for the old Java plugin.
853 static void* /* OJI type: JRIEnv* */
854 _getjavaenv(void);
855
856 // Deprecated entry points for the old Java plugin.
857 static void* /* OJI type: jref */
858 _getjavapeer(NPP aNPP);
859
860 static bool
861 _invoke(NPP aNPP, NPObject* npobj, NPIdentifier method, const NPVariant *args,
862 uint32_t argCount, NPVariant *result);
863
864 static bool
865 _invokedefault(NPP aNPP, NPObject* npobj, const NPVariant *args,
866 uint32_t argCount, NPVariant *result);
867
868 static bool
869 _evaluate(NPP aNPP, NPObject* npobj, NPString *script, NPVariant *result);
870
871 static bool
872 _getproperty(NPP aNPP, NPObject* npobj, NPIdentifier property,
873 NPVariant *result);
874
875 static bool
876 _setproperty(NPP aNPP, NPObject* npobj, NPIdentifier property,
877 const NPVariant *value);
878
879 static bool
880 _removeproperty(NPP aNPP, NPObject* npobj, NPIdentifier property);
881
882 static bool
883 _hasproperty(NPP aNPP, NPObject* npobj, NPIdentifier propertyName);
884
885 static bool
886 _hasmethod(NPP aNPP, NPObject* npobj, NPIdentifier methodName);
887
888 static bool
889 _enumerate(NPP aNPP, NPObject *npobj, NPIdentifier **identifier,
890 uint32_t *count);
891
892 static bool
893 _construct(NPP aNPP, NPObject* npobj, const NPVariant *args,
894 uint32_t argCount, NPVariant *result);
895
896 static void
897 _releasevariantvalue(NPVariant *variant);
898
899 static void
900 _setexception(NPObject* npobj, const NPUTF8 *message);
901
902 static void
903 _pushpopupsenabledstate(NPP aNPP, NPBool enabled);
904
905 static void
906 _poppopupsenabledstate(NPP aNPP);
907
908 static void
909 _pluginthreadasynccall(NPP instance, PluginThreadCallback func,
910 void *userData);
911
912 static NPError
913 _getvalueforurl(NPP npp, NPNURLVariable variable, const char *url,
914 char **value, uint32_t *len);
915
916 static NPError
917 _setvalueforurl(NPP npp, NPNURLVariable variable, const char *url,
918 const char *value, uint32_t len);
919
920 static NPError
921 _getauthenticationinfo(NPP npp, const char *protocol,
922 const char *host, int32_t port,
923 const char *scheme, const char *realm,
924 char **username, uint32_t *ulen,
925 char **password, uint32_t *plen);
926
927 static uint32_t
928 _scheduletimer(NPP instance, uint32_t interval, NPBool repeat,
929 void (*timerFunc)(NPP npp, uint32_t timerID));
930
931 static void
932 _unscheduletimer(NPP instance, uint32_t timerID);
933
934 static NPError
935 _popupcontextmenu(NPP instance, NPMenu* menu);
936
937 static NPBool
938 _convertpoint(NPP instance,
939 double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
940 double *destX, double *destY, NPCoordinateSpace destSpace);
941
942 static void
943 _urlredirectresponse(NPP instance, void* notifyData, NPBool allow);
944
945 static NPError
946 _initasyncsurface(NPP instance, NPSize *size,
947 NPImageFormat format, void *initData,
948 NPAsyncSurface *surface);
949
950 static NPError
951 _finalizeasyncsurface(NPP instance, NPAsyncSurface *surface);
952
953 static void
954 _setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed);
955
956 } /* namespace child */
957 } /* namespace plugins */
958 } /* namespace mozilla */
959
960 const NPNetscapeFuncs PluginModuleChild::sBrowserFuncs = {
961 sizeof(sBrowserFuncs),
962 (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR,
963 mozilla::plugins::child::_geturl,
964 mozilla::plugins::child::_posturl,
965 mozilla::plugins::child::_requestread,
966 mozilla::plugins::child::_newstream,
967 mozilla::plugins::child::_write,
968 mozilla::plugins::child::_destroystream,
969 mozilla::plugins::child::_status,
970 mozilla::plugins::child::_useragent,
971 mozilla::plugins::child::_memalloc,
972 mozilla::plugins::child::_memfree,
973 mozilla::plugins::child::_memflush,
974 mozilla::plugins::child::_reloadplugins,
975 mozilla::plugins::child::_getjavaenv,
976 mozilla::plugins::child::_getjavapeer,
977 mozilla::plugins::child::_geturlnotify,
978 mozilla::plugins::child::_posturlnotify,
979 mozilla::plugins::child::_getvalue,
980 mozilla::plugins::child::_setvalue,
981 mozilla::plugins::child::_invalidaterect,
982 mozilla::plugins::child::_invalidateregion,
983 mozilla::plugins::child::_forceredraw,
984 PluginModuleChild::NPN_GetStringIdentifier,
985 PluginModuleChild::NPN_GetStringIdentifiers,
986 PluginModuleChild::NPN_GetIntIdentifier,
987 PluginModuleChild::NPN_IdentifierIsString,
988 PluginModuleChild::NPN_UTF8FromIdentifier,
989 PluginModuleChild::NPN_IntFromIdentifier,
990 PluginModuleChild::NPN_CreateObject,
991 PluginModuleChild::NPN_RetainObject,
992 PluginModuleChild::NPN_ReleaseObject,
993 mozilla::plugins::child::_invoke,
994 mozilla::plugins::child::_invokedefault,
995 mozilla::plugins::child::_evaluate,
996 mozilla::plugins::child::_getproperty,
997 mozilla::plugins::child::_setproperty,
998 mozilla::plugins::child::_removeproperty,
999 mozilla::plugins::child::_hasproperty,
1000 mozilla::plugins::child::_hasmethod,
1001 mozilla::plugins::child::_releasevariantvalue,
1002 mozilla::plugins::child::_setexception,
1003 mozilla::plugins::child::_pushpopupsenabledstate,
1004 mozilla::plugins::child::_poppopupsenabledstate,
1005 mozilla::plugins::child::_enumerate,
1006 mozilla::plugins::child::_pluginthreadasynccall,
1007 mozilla::plugins::child::_construct,
1008 mozilla::plugins::child::_getvalueforurl,
1009 mozilla::plugins::child::_setvalueforurl,
1010 mozilla::plugins::child::_getauthenticationinfo,
1011 mozilla::plugins::child::_scheduletimer,
1012 mozilla::plugins::child::_unscheduletimer,
1013 mozilla::plugins::child::_popupcontextmenu,
1014 mozilla::plugins::child::_convertpoint,
1015 nullptr, // handleevent, unimplemented
1016 nullptr, // unfocusinstance, unimplemented
1017 mozilla::plugins::child::_urlredirectresponse,
1018 mozilla::plugins::child::_initasyncsurface,
1019 mozilla::plugins::child::_finalizeasyncsurface,
1020 mozilla::plugins::child::_setcurrentasyncsurface
1021 };
1022
1023 PluginInstanceChild*
1024 InstCast(NPP aNPP)
1025 {
1026 NS_ABORT_IF_FALSE(!!(aNPP->ndata), "nil instance");
1027 return static_cast<PluginInstanceChild*>(aNPP->ndata);
1028 }
1029
1030 namespace mozilla {
1031 namespace plugins {
1032 namespace child {
1033
1034 NPError
1035 _requestread(NPStream* aStream,
1036 NPByteRange* aRangeList)
1037 {
1038 PLUGIN_LOG_DEBUG_FUNCTION;
1039 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1040
1041 BrowserStreamChild* bs =
1042 static_cast<BrowserStreamChild*>(static_cast<AStream*>(aStream->ndata));
1043 bs->EnsureCorrectStream(aStream);
1044 return bs->NPN_RequestRead(aRangeList);
1045 }
1046
1047 NPError
1048 _geturlnotify(NPP aNPP,
1049 const char* aRelativeURL,
1050 const char* aTarget,
1051 void* aNotifyData)
1052 {
1053 PLUGIN_LOG_DEBUG_FUNCTION;
1054 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1055
1056 if (!aNPP) // nullptr check for nspluginwrapper (bug 561690)
1057 return NPERR_INVALID_INSTANCE_ERROR;
1058
1059 nsCString url = NullableString(aRelativeURL);
1060 StreamNotifyChild* sn = new StreamNotifyChild(url);
1061
1062 NPError err;
1063 InstCast(aNPP)->CallPStreamNotifyConstructor(
1064 sn, url, NullableString(aTarget), false, nsCString(), false, &err);
1065
1066 if (NPERR_NO_ERROR == err) {
1067 // If NPN_PostURLNotify fails, the parent will immediately send us
1068 // a PStreamNotifyDestructor, which should not call NPP_URLNotify.
1069 sn->SetValid(aNotifyData);
1070 }
1071
1072 return err;
1073 }
1074
1075 NPError
1076 _getvalue(NPP aNPP,
1077 NPNVariable aVariable,
1078 void* aValue)
1079 {
1080 PLUGIN_LOG_DEBUG_FUNCTION;
1081 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1082
1083 switch (aVariable) {
1084 // Copied from nsNPAPIPlugin.cpp
1085 case NPNVToolkit:
1086 #if defined(MOZ_WIDGET_GTK) || defined(MOZ_WIDGET_QT)
1087 *static_cast<NPNToolkitType*>(aValue) = NPNVGtk2;
1088 return NPERR_NO_ERROR;
1089 #endif
1090 return NPERR_GENERIC_ERROR;
1091
1092 case NPNVjavascriptEnabledBool: // Intentional fall-through
1093 case NPNVasdEnabledBool: // Intentional fall-through
1094 case NPNVisOfflineBool: // Intentional fall-through
1095 case NPNVSupportsXEmbedBool: // Intentional fall-through
1096 case NPNVSupportsWindowless: { // Intentional fall-through
1097 NPError result;
1098 bool value;
1099 PluginModuleChild::current()->
1100 CallNPN_GetValue_WithBoolReturn(aVariable, &result, &value);
1101 *(NPBool*)aValue = value ? true : false;
1102 return result;
1103 }
1104 #if (MOZ_WIDGET_GTK == 2)
1105 case NPNVxDisplay: {
1106 if (aNPP) {
1107 return InstCast(aNPP)->NPN_GetValue(aVariable, aValue);
1108 }
1109 else {
1110 *(void **)aValue = xt_client_get_display();
1111 }
1112 return NPERR_NO_ERROR;
1113 }
1114 case NPNVxtAppContext:
1115 return NPERR_GENERIC_ERROR;
1116 #endif
1117 default: {
1118 if (aNPP) {
1119 return InstCast(aNPP)->NPN_GetValue(aVariable, aValue);
1120 }
1121
1122 NS_WARNING("Null NPP!");
1123 return NPERR_INVALID_INSTANCE_ERROR;
1124 }
1125 }
1126
1127 NS_NOTREACHED("Shouldn't get here!");
1128 return NPERR_GENERIC_ERROR;
1129 }
1130
1131 NPError
1132 _setvalue(NPP aNPP,
1133 NPPVariable aVariable,
1134 void* aValue)
1135 {
1136 PLUGIN_LOG_DEBUG_FUNCTION;
1137 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1138 return InstCast(aNPP)->NPN_SetValue(aVariable, aValue);
1139 }
1140
1141 NPError
1142 _geturl(NPP aNPP,
1143 const char* aRelativeURL,
1144 const char* aTarget)
1145 {
1146 PLUGIN_LOG_DEBUG_FUNCTION;
1147 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1148
1149 NPError err;
1150 InstCast(aNPP)->CallNPN_GetURL(NullableString(aRelativeURL),
1151 NullableString(aTarget), &err);
1152 return err;
1153 }
1154
1155 NPError
1156 _posturlnotify(NPP aNPP,
1157 const char* aRelativeURL,
1158 const char* aTarget,
1159 uint32_t aLength,
1160 const char* aBuffer,
1161 NPBool aIsFile,
1162 void* aNotifyData)
1163 {
1164 PLUGIN_LOG_DEBUG_FUNCTION;
1165 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1166
1167 if (!aBuffer)
1168 return NPERR_INVALID_PARAM;
1169
1170 nsCString url = NullableString(aRelativeURL);
1171 StreamNotifyChild* sn = new StreamNotifyChild(url);
1172
1173 NPError err;
1174 InstCast(aNPP)->CallPStreamNotifyConstructor(
1175 sn, url, NullableString(aTarget), true,
1176 nsCString(aBuffer, aLength), aIsFile, &err);
1177
1178 if (NPERR_NO_ERROR == err) {
1179 // If NPN_PostURLNotify fails, the parent will immediately send us
1180 // a PStreamNotifyDestructor, which should not call NPP_URLNotify.
1181 sn->SetValid(aNotifyData);
1182 }
1183
1184 return err;
1185 }
1186
1187 NPError
1188 _posturl(NPP aNPP,
1189 const char* aRelativeURL,
1190 const char* aTarget,
1191 uint32_t aLength,
1192 const char* aBuffer,
1193 NPBool aIsFile)
1194 {
1195 PLUGIN_LOG_DEBUG_FUNCTION;
1196 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1197
1198 NPError err;
1199 // FIXME what should happen when |aBuffer| is null?
1200 InstCast(aNPP)->CallNPN_PostURL(NullableString(aRelativeURL),
1201 NullableString(aTarget),
1202 nsDependentCString(aBuffer, aLength),
1203 aIsFile, &err);
1204 return err;
1205 }
1206
1207 NPError
1208 _newstream(NPP aNPP,
1209 NPMIMEType aMIMEType,
1210 const char* aWindow,
1211 NPStream** aStream)
1212 {
1213 PLUGIN_LOG_DEBUG_FUNCTION;
1214 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1215 return InstCast(aNPP)->NPN_NewStream(aMIMEType, aWindow, aStream);
1216 }
1217
1218 int32_t
1219 _write(NPP aNPP,
1220 NPStream* aStream,
1221 int32_t aLength,
1222 void* aBuffer)
1223 {
1224 PLUGIN_LOG_DEBUG_FUNCTION;
1225 ENSURE_PLUGIN_THREAD(0);
1226
1227 PluginStreamChild* ps =
1228 static_cast<PluginStreamChild*>(static_cast<AStream*>(aStream->ndata));
1229 ps->EnsureCorrectInstance(InstCast(aNPP));
1230 ps->EnsureCorrectStream(aStream);
1231 return ps->NPN_Write(aLength, aBuffer);
1232 }
1233
1234 NPError
1235 _destroystream(NPP aNPP,
1236 NPStream* aStream,
1237 NPError aReason)
1238 {
1239 PLUGIN_LOG_DEBUG_FUNCTION;
1240 ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
1241
1242 PluginInstanceChild* p = InstCast(aNPP);
1243 AStream* s = static_cast<AStream*>(aStream->ndata);
1244 if (s->IsBrowserStream()) {
1245 BrowserStreamChild* bs = static_cast<BrowserStreamChild*>(s);
1246 bs->EnsureCorrectInstance(p);
1247 bs->NPN_DestroyStream(aReason);
1248 }
1249 else {
1250 PluginStreamChild* ps = static_cast<PluginStreamChild*>(s);
1251 ps->EnsureCorrectInstance(p);
1252 PPluginStreamChild::Call__delete__(ps, aReason, false);
1253 }
1254 return NPERR_NO_ERROR;
1255 }
1256
1257 void
1258 _status(NPP aNPP,
1259 const char* aMessage)
1260 {
1261 PLUGIN_LOG_DEBUG_FUNCTION;
1262 ENSURE_PLUGIN_THREAD_VOID();
1263 NS_WARNING("Not yet implemented!");
1264 }
1265
1266 void
1267 _memfree(void* aPtr)
1268 {
1269 PLUGIN_LOG_DEBUG_FUNCTION;
1270 // Only assert plugin thread here for consistency with in-process plugins.
1271 AssertPluginThread();
1272 NS_Free(aPtr);
1273 }
1274
1275 uint32_t
1276 _memflush(uint32_t aSize)
1277 {
1278 PLUGIN_LOG_DEBUG_FUNCTION;
1279 // Only assert plugin thread here for consistency with in-process plugins.
1280 AssertPluginThread();
1281 return 0;
1282 }
1283
1284 void
1285 _reloadplugins(NPBool aReloadPages)
1286 {
1287 PLUGIN_LOG_DEBUG_FUNCTION;
1288 ENSURE_PLUGIN_THREAD_VOID();
1289
1290 PluginModuleChild::current()->SendNPN_ReloadPlugins(!!aReloadPages);
1291 }
1292
1293 void
1294 _invalidaterect(NPP aNPP,
1295 NPRect* aInvalidRect)
1296 {
1297 PLUGIN_LOG_DEBUG_FUNCTION;
1298 ENSURE_PLUGIN_THREAD_VOID();
1299 // nullptr check for nspluginwrapper (bug 548434)
1300 if (aNPP) {
1301 InstCast(aNPP)->InvalidateRect(aInvalidRect);
1302 }
1303 }
1304
1305 void
1306 _invalidateregion(NPP aNPP,
1307 NPRegion aInvalidRegion)
1308 {
1309 PLUGIN_LOG_DEBUG_FUNCTION;
1310 ENSURE_PLUGIN_THREAD_VOID();
1311 NS_WARNING("Not yet implemented!");
1312 }
1313
1314 void
1315 _forceredraw(NPP aNPP)
1316 {
1317 PLUGIN_LOG_DEBUG_FUNCTION;
1318 ENSURE_PLUGIN_THREAD_VOID();
1319
1320 // We ignore calls to NPN_ForceRedraw. Such calls should
1321 // never be necessary.
1322 }
1323
1324 const char*
1325 _useragent(NPP aNPP)
1326 {
1327 PLUGIN_LOG_DEBUG_FUNCTION;
1328 ENSURE_PLUGIN_THREAD(nullptr);
1329 return PluginModuleChild::current()->GetUserAgent();
1330 }
1331
1332 void*
1333 _memalloc(uint32_t aSize)
1334 {
1335 PLUGIN_LOG_DEBUG_FUNCTION;
1336 // Only assert plugin thread here for consistency with in-process plugins.
1337 AssertPluginThread();
1338 return NS_Alloc(aSize);
1339 }
1340
1341 // Deprecated entry points for the old Java plugin.
1342 void* /* OJI type: JRIEnv* */
1343 _getjavaenv(void)
1344 {
1345 PLUGIN_LOG_DEBUG_FUNCTION;
1346 return 0;
1347 }
1348
1349 void* /* OJI type: jref */
1350 _getjavapeer(NPP aNPP)
1351 {
1352 PLUGIN_LOG_DEBUG_FUNCTION;
1353 return 0;
1354 }
1355
1356 bool
1357 _invoke(NPP aNPP,
1358 NPObject* aNPObj,
1359 NPIdentifier aMethod,
1360 const NPVariant* aArgs,
1361 uint32_t aArgCount,
1362 NPVariant* aResult)
1363 {
1364 PLUGIN_LOG_DEBUG_FUNCTION;
1365 ENSURE_PLUGIN_THREAD(false);
1366
1367 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->invoke)
1368 return false;
1369
1370 return aNPObj->_class->invoke(aNPObj, aMethod, aArgs, aArgCount, aResult);
1371 }
1372
1373 bool
1374 _invokedefault(NPP aNPP,
1375 NPObject* aNPObj,
1376 const NPVariant* aArgs,
1377 uint32_t aArgCount,
1378 NPVariant* aResult)
1379 {
1380 PLUGIN_LOG_DEBUG_FUNCTION;
1381 ENSURE_PLUGIN_THREAD(false);
1382
1383 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->invokeDefault)
1384 return false;
1385
1386 return aNPObj->_class->invokeDefault(aNPObj, aArgs, aArgCount, aResult);
1387 }
1388
1389 bool
1390 _evaluate(NPP aNPP,
1391 NPObject* aObject,
1392 NPString* aScript,
1393 NPVariant* aResult)
1394 {
1395 PLUGIN_LOG_DEBUG_FUNCTION;
1396 ENSURE_PLUGIN_THREAD(false);
1397
1398 if (!(aNPP && aObject && aScript && aResult)) {
1399 NS_ERROR("Bad arguments!");
1400 return false;
1401 }
1402
1403 PluginScriptableObjectChild* actor =
1404 InstCast(aNPP)->GetActorForNPObject(aObject);
1405 if (!actor) {
1406 NS_ERROR("Failed to create actor?!");
1407 return false;
1408 }
1409
1410 #ifdef XP_WIN
1411 if (gDelayFlashFocusReplyUntilEval) {
1412 ReplyMessage(0);
1413 gDelayFlashFocusReplyUntilEval = false;
1414 }
1415 #endif
1416
1417 return actor->Evaluate(aScript, aResult);
1418 }
1419
1420 bool
1421 _getproperty(NPP aNPP,
1422 NPObject* aNPObj,
1423 NPIdentifier aPropertyName,
1424 NPVariant* aResult)
1425 {
1426 PLUGIN_LOG_DEBUG_FUNCTION;
1427 ENSURE_PLUGIN_THREAD(false);
1428
1429 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->getProperty)
1430 return false;
1431
1432 return aNPObj->_class->getProperty(aNPObj, aPropertyName, aResult);
1433 }
1434
1435 bool
1436 _setproperty(NPP aNPP,
1437 NPObject* aNPObj,
1438 NPIdentifier aPropertyName,
1439 const NPVariant* aValue)
1440 {
1441 PLUGIN_LOG_DEBUG_FUNCTION;
1442 ENSURE_PLUGIN_THREAD(false);
1443
1444 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->setProperty)
1445 return false;
1446
1447 return aNPObj->_class->setProperty(aNPObj, aPropertyName, aValue);
1448 }
1449
1450 bool
1451 _removeproperty(NPP aNPP,
1452 NPObject* aNPObj,
1453 NPIdentifier aPropertyName)
1454 {
1455 PLUGIN_LOG_DEBUG_FUNCTION;
1456 ENSURE_PLUGIN_THREAD(false);
1457
1458 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->removeProperty)
1459 return false;
1460
1461 return aNPObj->_class->removeProperty(aNPObj, aPropertyName);
1462 }
1463
1464 bool
1465 _hasproperty(NPP aNPP,
1466 NPObject* aNPObj,
1467 NPIdentifier aPropertyName)
1468 {
1469 PLUGIN_LOG_DEBUG_FUNCTION;
1470 ENSURE_PLUGIN_THREAD(false);
1471
1472 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->hasProperty)
1473 return false;
1474
1475 return aNPObj->_class->hasProperty(aNPObj, aPropertyName);
1476 }
1477
1478 bool
1479 _hasmethod(NPP aNPP,
1480 NPObject* aNPObj,
1481 NPIdentifier aMethodName)
1482 {
1483 PLUGIN_LOG_DEBUG_FUNCTION;
1484 ENSURE_PLUGIN_THREAD(false);
1485
1486 if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->hasMethod)
1487 return false;
1488
1489 return aNPObj->_class->hasMethod(aNPObj, aMethodName);
1490 }
1491
1492 bool
1493 _enumerate(NPP aNPP,
1494 NPObject* aNPObj,
1495 NPIdentifier** aIdentifiers,
1496 uint32_t* aCount)
1497 {
1498 PLUGIN_LOG_DEBUG_FUNCTION;
1499 ENSURE_PLUGIN_THREAD(false);
1500
1501 if (!aNPP || !aNPObj || !aNPObj->_class)
1502 return false;
1503
1504 if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(aNPObj->_class) ||
1505 !aNPObj->_class->enumerate) {
1506 *aIdentifiers = 0;
1507 *aCount = 0;
1508 return true;
1509 }
1510
1511 return aNPObj->_class->enumerate(aNPObj, aIdentifiers, aCount);
1512 }
1513
1514 bool
1515 _construct(NPP aNPP,
1516 NPObject* aNPObj,
1517 const NPVariant* aArgs,
1518 uint32_t aArgCount,
1519 NPVariant* aResult)
1520 {
1521 PLUGIN_LOG_DEBUG_FUNCTION;
1522 ENSURE_PLUGIN_THREAD(false);
1523
1524 if (!aNPP || !aNPObj || !aNPObj->_class ||
1525 !NP_CLASS_STRUCT_VERSION_HAS_CTOR(aNPObj->_class) ||
1526 !aNPObj->_class->construct) {
1527 return false;
1528 }
1529
1530 return aNPObj->_class->construct(aNPObj, aArgs, aArgCount, aResult);
1531 }
1532
1533 void
1534 _releasevariantvalue(NPVariant* aVariant)
1535 {
1536 PLUGIN_LOG_DEBUG_FUNCTION;
1537 // Only assert plugin thread here for consistency with in-process plugins.
1538 AssertPluginThread();
1539
1540 if (NPVARIANT_IS_STRING(*aVariant)) {
1541 NPString str = NPVARIANT_TO_STRING(*aVariant);
1542 free(const_cast<NPUTF8*>(str.UTF8Characters));
1543 }
1544 else if (NPVARIANT_IS_OBJECT(*aVariant)) {
1545 NPObject* object = NPVARIANT_TO_OBJECT(*aVariant);
1546 if (object) {
1547 PluginModuleChild::NPN_ReleaseObject(object);
1548 }
1549 }
1550 VOID_TO_NPVARIANT(*aVariant);
1551 }
1552
1553 void
1554 _setexception(NPObject* aNPObj,
1555 const NPUTF8* aMessage)
1556 {
1557 PLUGIN_LOG_DEBUG_FUNCTION;
1558 ENSURE_PLUGIN_THREAD_VOID();
1559
1560 PluginModuleChild* self = PluginModuleChild::current();
1561 PluginScriptableObjectChild* actor = nullptr;
1562 if (aNPObj) {
1563 actor = self->GetActorForNPObject(aNPObj);
1564 if (!actor) {
1565 NS_ERROR("Failed to get actor!");
1566 return;
1567 }
1568 }
1569
1570 self->SendNPN_SetException(static_cast<PPluginScriptableObjectChild*>(actor),
1571 NullableString(aMessage));
1572 }
1573
1574 void
1575 _pushpopupsenabledstate(NPP aNPP,
1576 NPBool aEnabled)
1577 {
1578 PLUGIN_LOG_DEBUG_FUNCTION;
1579 ENSURE_PLUGIN_THREAD_VOID();
1580
1581 InstCast(aNPP)->CallNPN_PushPopupsEnabledState(aEnabled ? true : false);
1582 }
1583
1584 void
1585 _poppopupsenabledstate(NPP aNPP)
1586 {
1587 PLUGIN_LOG_DEBUG_FUNCTION;
1588 ENSURE_PLUGIN_THREAD_VOID();
1589
1590 InstCast(aNPP)->CallNPN_PopPopupsEnabledState();
1591 }
1592
1593 void
1594 _pluginthreadasynccall(NPP aNPP,
1595 PluginThreadCallback aFunc,
1596 void* aUserData)
1597 {
1598 PLUGIN_LOG_DEBUG_FUNCTION;
1599 if (!aFunc)
1600 return;
1601
1602 InstCast(aNPP)->AsyncCall(aFunc, aUserData);
1603 }
1604
1605 NPError
1606 _getvalueforurl(NPP npp, NPNURLVariable variable, const char *url,
1607 char **value, uint32_t *len)
1608 {
1609 PLUGIN_LOG_DEBUG_FUNCTION;
1610 AssertPluginThread();
1611
1612 if (!url)
1613 return NPERR_INVALID_URL;
1614
1615 if (!npp || !value || !len)
1616 return NPERR_INVALID_PARAM;
1617
1618 switch (variable) {
1619 case NPNURLVCookie:
1620 case NPNURLVProxy:
1621 nsCString v;
1622 NPError result;
1623 InstCast(npp)->
1624 CallNPN_GetValueForURL(variable, nsCString(url), &v, &result);
1625 if (NPERR_NO_ERROR == result) {
1626 *value = ToNewCString(v);
1627 *len = v.Length();
1628 }
1629 return result;
1630 }
1631
1632 return NPERR_INVALID_PARAM;
1633 }
1634
1635 NPError
1636 _setvalueforurl(NPP npp, NPNURLVariable variable, const char *url,
1637 const char *value, uint32_t len)
1638 {
1639 PLUGIN_LOG_DEBUG_FUNCTION;
1640 AssertPluginThread();
1641
1642 if (!value)
1643 return NPERR_INVALID_PARAM;
1644
1645 if (!url)
1646 return NPERR_INVALID_URL;
1647
1648 switch (variable) {
1649 case NPNURLVCookie:
1650 case NPNURLVProxy:
1651 NPError result;
1652 InstCast(npp)->CallNPN_SetValueForURL(variable, nsCString(url),
1653 nsDependentCString(value, len),
1654 &result);
1655 return result;
1656 }
1657
1658 return NPERR_INVALID_PARAM;
1659 }
1660
1661 NPError
1662 _getauthenticationinfo(NPP npp, const char *protocol,
1663 const char *host, int32_t port,
1664 const char *scheme, const char *realm,
1665 char **username, uint32_t *ulen,
1666 char **password, uint32_t *plen)
1667 {
1668 PLUGIN_LOG_DEBUG_FUNCTION;
1669 AssertPluginThread();
1670
1671 if (!protocol || !host || !scheme || !realm || !username || !ulen ||
1672 !password || !plen)
1673 return NPERR_INVALID_PARAM;
1674
1675 nsCString u;
1676 nsCString p;
1677 NPError result;
1678 InstCast(npp)->
1679 CallNPN_GetAuthenticationInfo(nsDependentCString(protocol),
1680 nsDependentCString(host),
1681 port,
1682 nsDependentCString(scheme),
1683 nsDependentCString(realm),
1684 &u, &p, &result);
1685 if (NPERR_NO_ERROR == result) {
1686 *username = ToNewCString(u);
1687 *ulen = u.Length();
1688 *password = ToNewCString(p);
1689 *plen = p.Length();
1690 }
1691 return result;
1692 }
1693
1694 uint32_t
1695 _scheduletimer(NPP npp, uint32_t interval, NPBool repeat,
1696 void (*timerFunc)(NPP npp, uint32_t timerID))
1697 {
1698 PLUGIN_LOG_DEBUG_FUNCTION;
1699 AssertPluginThread();
1700 return InstCast(npp)->ScheduleTimer(interval, repeat, timerFunc);
1701 }
1702
1703 void
1704 _unscheduletimer(NPP npp, uint32_t timerID)
1705 {
1706 PLUGIN_LOG_DEBUG_FUNCTION;
1707 AssertPluginThread();
1708 InstCast(npp)->UnscheduleTimer(timerID);
1709 }
1710
1711
1712 #ifdef OS_MACOSX
1713 static void ProcessBrowserEvents(void* pluginModule) {
1714 PluginModuleChild* pmc = static_cast<PluginModuleChild*>(pluginModule);
1715
1716 if (!pmc)
1717 return;
1718
1719 pmc->CallProcessSomeEvents();
1720 }
1721 #endif
1722
1723 NPError
1724 _popupcontextmenu(NPP instance, NPMenu* menu)
1725 {
1726 PLUGIN_LOG_DEBUG_FUNCTION;
1727 AssertPluginThread();
1728
1729 #ifdef MOZ_WIDGET_COCOA
1730 double pluginX, pluginY;
1731 double screenX, screenY;
1732
1733 const NPCocoaEvent* currentEvent = InstCast(instance)->getCurrentEvent();
1734 if (!currentEvent) {
1735 return NPERR_GENERIC_ERROR;
1736 }
1737
1738 // Ensure that the events has an x/y value.
1739 if (currentEvent->type != NPCocoaEventMouseDown &&
1740 currentEvent->type != NPCocoaEventMouseUp &&
1741 currentEvent->type != NPCocoaEventMouseMoved &&
1742 currentEvent->type != NPCocoaEventMouseEntered &&
1743 currentEvent->type != NPCocoaEventMouseExited &&
1744 currentEvent->type != NPCocoaEventMouseDragged) {
1745 return NPERR_GENERIC_ERROR;
1746 }
1747
1748 pluginX = currentEvent->data.mouse.pluginX;
1749 pluginY = currentEvent->data.mouse.pluginY;
1750
1751 if ((pluginX < 0.0) || (pluginY < 0.0))
1752 return NPERR_GENERIC_ERROR;
1753
1754 NPBool success = _convertpoint(instance,
1755 pluginX, pluginY, NPCoordinateSpacePlugin,
1756 &screenX, &screenY, NPCoordinateSpaceScreen);
1757
1758 if (success) {
1759 return mozilla::plugins::PluginUtilsOSX::ShowCocoaContextMenu(menu,
1760 screenX, screenY,
1761 PluginModuleChild::current(),
1762 ProcessBrowserEvents);
1763 } else {
1764 NS_WARNING("Convertpoint failed, could not created contextmenu.");
1765 return NPERR_GENERIC_ERROR;
1766 }
1767
1768 #else
1769 NS_WARNING("Not supported on this platform!");
1770 return NPERR_GENERIC_ERROR;
1771 #endif
1772 }
1773
1774 NPBool
1775 _convertpoint(NPP instance,
1776 double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
1777 double *destX, double *destY, NPCoordinateSpace destSpace)
1778 {
1779 PLUGIN_LOG_DEBUG_FUNCTION;
1780 if (!IsPluginThread()) {
1781 NS_WARNING("Not running on the plugin's main thread!");
1782 return false;
1783 }
1784
1785 double rDestX = 0;
1786 bool ignoreDestX = !destX;
1787 double rDestY = 0;
1788 bool ignoreDestY = !destY;
1789 bool result = false;
1790 InstCast(instance)->CallNPN_ConvertPoint(sourceX, ignoreDestX, sourceY, ignoreDestY, sourceSpace, destSpace,
1791 &rDestX, &rDestY, &result);
1792 if (result) {
1793 if (destX)
1794 *destX = rDestX;
1795 if (destY)
1796 *destY = rDestY;
1797 }
1798
1799 return result;
1800 }
1801
1802 void
1803 _urlredirectresponse(NPP instance, void* notifyData, NPBool allow)
1804 {
1805 InstCast(instance)->NPN_URLRedirectResponse(notifyData, allow);
1806 }
1807
1808 NPError
1809 _initasyncsurface(NPP instance, NPSize *size,
1810 NPImageFormat format, void *initData,
1811 NPAsyncSurface *surface)
1812 {
1813 return InstCast(instance)->NPN_InitAsyncSurface(size, format, initData, surface);
1814 }
1815
1816 NPError
1817 _finalizeasyncsurface(NPP instance, NPAsyncSurface *surface)
1818 {
1819 return InstCast(instance)->NPN_FinalizeAsyncSurface(surface);
1820 }
1821
1822 void
1823 _setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
1824 {
1825 InstCast(instance)->NPN_SetCurrentAsyncSurface(surface, changed);
1826 }
1827
1828 } /* namespace child */
1829 } /* namespace plugins */
1830 } /* namespace mozilla */
1831
1832 //-----------------------------------------------------------------------------
1833
1834 bool
1835 PluginModuleChild::AnswerNP_GetEntryPoints(NPError* _retval)
1836 {
1837 PLUGIN_LOG_DEBUG_METHOD;
1838 AssertPluginThread();
1839
1840 #if defined(OS_LINUX) || defined(OS_BSD)
1841 return true;
1842 #elif defined(OS_WIN) || defined(OS_MACOSX)
1843 *_retval = mGetEntryPointsFunc(&mFunctions);
1844 return true;
1845 #else
1846 # error Please implement me for your platform
1847 #endif
1848 }
1849
1850 bool
1851 PluginModuleChild::AnswerNP_Initialize(const uint32_t& aFlags, NPError* _retval)
1852 {
1853 PLUGIN_LOG_DEBUG_METHOD;
1854 AssertPluginThread();
1855
1856 mAsyncDrawingAllowed = aFlags & kAllowAsyncDrawing;
1857
1858 #ifdef OS_WIN
1859 SetEventHooks();
1860 #endif
1861
1862 #ifdef MOZ_X11
1863 // Send the parent our X socket to act as a proxy reference for our X
1864 // resources.
1865 int xSocketFd = ConnectionNumber(DefaultXDisplay());
1866 SendBackUpXResources(FileDescriptor(xSocketFd));
1867 #endif
1868
1869 #if defined(OS_LINUX) || defined(OS_BSD)
1870 *_retval = mInitializeFunc(&sBrowserFuncs, &mFunctions);
1871 return true;
1872 #elif defined(OS_WIN) || defined(OS_MACOSX)
1873 *_retval = mInitializeFunc(&sBrowserFuncs);
1874 return true;
1875 #else
1876 # error Please implement me for your platform
1877 #endif
1878 }
1879
1880 PPluginIdentifierChild*
1881 PluginModuleChild::AllocPPluginIdentifierChild(const nsCString& aString,
1882 const int32_t& aInt,
1883 const bool& aTemporary)
1884 {
1885 // We cannot call SetPermanent within this function because Manager() isn't
1886 // set up yet.
1887 if (aString.IsVoid()) {
1888 return new PluginIdentifierChildInt(aInt);
1889 }
1890 return new PluginIdentifierChildString(aString);
1891 }
1892
1893 bool
1894 PluginModuleChild::RecvPPluginIdentifierConstructor(PPluginIdentifierChild* actor,
1895 const nsCString& aString,
1896 const int32_t& aInt,
1897 const bool& aTemporary)
1898 {
1899 if (!aTemporary) {
1900 static_cast<PluginIdentifierChild*>(actor)->MakePermanent();
1901 }
1902 return true;
1903 }
1904
1905 bool
1906 PluginModuleChild::DeallocPPluginIdentifierChild(PPluginIdentifierChild* aActor)
1907 {
1908 delete aActor;
1909 return true;
1910 }
1911
1912 #if defined(XP_WIN)
1913 BOOL WINAPI
1914 PMCGetWindowInfoHook(HWND hWnd, PWINDOWINFO pwi)
1915 {
1916 if (!pwi)
1917 return FALSE;
1918
1919 if (!sGetWindowInfoPtrStub) {
1920 NS_ASSERTION(FALSE, "Something is horribly wrong in PMCGetWindowInfoHook!");
1921 return FALSE;
1922 }
1923
1924 if (!sBrowserHwnd) {
1925 wchar_t szClass[20];
1926 if (GetClassNameW(hWnd, szClass, ArrayLength(szClass)) &&
1927 !wcscmp(szClass, kMozillaWindowClass)) {
1928 sBrowserHwnd = hWnd;
1929 }
1930 }
1931 // Oddity: flash does strange rect comparisons for mouse input destined for
1932 // it's internal settings window. Post removing sub widgets for tabs, touch
1933 // this up so they get the rect they expect.
1934 // XXX potentially tie this to a specific major version?
1935 BOOL result = sGetWindowInfoPtrStub(hWnd, pwi);
1936 if (sBrowserHwnd && sBrowserHwnd == hWnd)
1937 pwi->rcWindow = pwi->rcClient;
1938 return result;
1939 }
1940 #endif
1941
1942 PPluginInstanceChild*
1943 PluginModuleChild::AllocPPluginInstanceChild(const nsCString& aMimeType,
1944 const uint16_t& aMode,
1945 const InfallibleTArray<nsCString>& aNames,
1946 const InfallibleTArray<nsCString>& aValues,
1947 NPError* rv)
1948 {
1949 PLUGIN_LOG_DEBUG_METHOD;
1950 AssertPluginThread();
1951
1952 InitQuirksModes(aMimeType);
1953
1954 #ifdef XP_WIN
1955 if ((mQuirks & QUIRK_FLASH_HOOK_GETWINDOWINFO) &&
1956 !sGetWindowInfoPtrStub) {
1957 sUser32Intercept.Init("user32.dll");
1958 sUser32Intercept.AddHook("GetWindowInfo", reinterpret_cast<intptr_t>(PMCGetWindowInfoHook),
1959 (void**) &sGetWindowInfoPtrStub);
1960 }
1961 #endif
1962
1963 return new PluginInstanceChild(&mFunctions);
1964 }
1965
1966 void
1967 PluginModuleChild::InitQuirksModes(const nsCString& aMimeType)
1968 {
1969 if (mQuirks != QUIRKS_NOT_INITIALIZED)
1970 return;
1971 mQuirks = 0;
1972 // application/x-silverlight
1973 // application/x-silverlight-2
1974 NS_NAMED_LITERAL_CSTRING(silverlight, "application/x-silverlight");
1975 if (FindInReadable(silverlight, aMimeType)) {
1976 mQuirks |= QUIRK_SILVERLIGHT_DEFAULT_TRANSPARENT;
1977 #ifdef OS_WIN
1978 mQuirks |= QUIRK_WINLESS_TRACKPOPUP_HOOK;
1979 mQuirks |= QUIRK_SILVERLIGHT_FOCUS_CHECK_PARENT;
1980 #endif
1981 }
1982
1983 #ifdef OS_WIN
1984 // application/x-shockwave-flash
1985 NS_NAMED_LITERAL_CSTRING(flash, "application/x-shockwave-flash");
1986 if (FindInReadable(flash, aMimeType)) {
1987 mQuirks |= QUIRK_WINLESS_TRACKPOPUP_HOOK;
1988 mQuirks |= QUIRK_FLASH_THROTTLE_WMUSER_EVENTS;
1989 mQuirks |= QUIRK_FLASH_HOOK_SETLONGPTR;
1990 mQuirks |= QUIRK_FLASH_HOOK_GETWINDOWINFO;
1991 mQuirks |= QUIRK_FLASH_FIXUP_MOUSE_CAPTURE;
1992 }
1993
1994 // QuickTime plugin usually loaded with audio/mpeg mimetype
1995 NS_NAMED_LITERAL_CSTRING(quicktime, "npqtplugin");
1996 if (FindInReadable(quicktime, mPluginFilename)) {
1997 mQuirks |= QUIRK_QUICKTIME_AVOID_SETWINDOW;
1998 }
1999 #endif
2000
2001 #ifdef XP_MACOSX
2002 // Whitelist Flash and Quicktime to support offline renderer
2003 NS_NAMED_LITERAL_CSTRING(flash, "application/x-shockwave-flash");
2004 NS_NAMED_LITERAL_CSTRING(quicktime, "QuickTime Plugin.plugin");
2005 if (FindInReadable(flash, aMimeType)) {
2006 mQuirks |= QUIRK_FLASH_AVOID_CGMODE_CRASHES;
2007 }
2008 if (FindInReadable(flash, aMimeType) ||
2009 FindInReadable(quicktime, mPluginFilename)) {
2010 mQuirks |= QUIRK_ALLOW_OFFLINE_RENDERER;
2011 }
2012 #endif
2013 }
2014
2015 bool
2016 PluginModuleChild::AnswerPPluginInstanceConstructor(PPluginInstanceChild* aActor,
2017 const nsCString& aMimeType,
2018 const uint16_t& aMode,
2019 const InfallibleTArray<nsCString>& aNames,
2020 const InfallibleTArray<nsCString>& aValues,
2021 NPError* rv)
2022 {
2023 PLUGIN_LOG_DEBUG_METHOD;
2024 AssertPluginThread();
2025
2026 PluginInstanceChild* childInstance =
2027 reinterpret_cast<PluginInstanceChild*>(aActor);
2028 NS_ASSERTION(childInstance, "Null actor!");
2029
2030 // unpack the arguments into a C format
2031 int argc = aNames.Length();
2032 NS_ASSERTION(argc == (int) aValues.Length(),
2033 "argn.length != argv.length");
2034
2035 nsAutoArrayPtr<char*> argn(new char*[1 + argc]);
2036 nsAutoArrayPtr<char*> argv(new char*[1 + argc]);
2037 argn[argc] = 0;
2038 argv[argc] = 0;
2039
2040 for (int i = 0; i < argc; ++i) {
2041 argn[i] = const_cast<char*>(NullableStringGet(aNames[i]));
2042 argv[i] = const_cast<char*>(NullableStringGet(aValues[i]));
2043 }
2044
2045 NPP npp = childInstance->GetNPP();
2046
2047 // FIXME/cjones: use SAFE_CALL stuff
2048 *rv = mFunctions.newp((char*)NullableStringGet(aMimeType),
2049 npp,
2050 aMode,
2051 argc,
2052 argn,
2053 argv,
2054 0);
2055 if (NPERR_NO_ERROR != *rv) {
2056 return true;
2057 }
2058
2059 childInstance->Initialize();
2060
2061 #if defined(XP_MACOSX) && defined(__i386__)
2062 // If an i386 Mac OS X plugin has selected the Carbon event model then
2063 // we have to fail. We do not support putting Carbon event model plugins
2064 // out of process. Note that Carbon is the default model so out of process
2065 // plugins need to actively negotiate something else in order to work
2066 // out of process.
2067 if (childInstance->EventModel() == NPEventModelCarbon) {
2068 // Send notification that a plugin tried to negotiate Carbon NPAPI so that
2069 // users can be notified that restarting the browser in i386 mode may allow
2070 // them to use the plugin.
2071 childInstance->SendNegotiatedCarbon();
2072
2073 // Fail to instantiate.
2074 *rv = NPERR_MODULE_LOAD_FAILED_ERROR;
2075 }
2076 #endif
2077
2078 return true;
2079 }
2080
2081 bool
2082 PluginModuleChild::DeallocPPluginInstanceChild(PPluginInstanceChild* aActor)
2083 {
2084 PLUGIN_LOG_DEBUG_METHOD;
2085 AssertPluginThread();
2086
2087 delete aActor;
2088
2089 return true;
2090 }
2091
2092 NPObject*
2093 PluginModuleChild::NPN_CreateObject(NPP aNPP, NPClass* aClass)
2094 {
2095 PLUGIN_LOG_DEBUG_FUNCTION;
2096 ENSURE_PLUGIN_THREAD(nullptr);
2097
2098 PluginInstanceChild* i = InstCast(aNPP);
2099 if (i->mDeletingHash) {
2100 NS_ERROR("Plugin used NPP after NPP_Destroy");
2101 return nullptr;
2102 }
2103
2104 NPObject* newObject;
2105 if (aClass && aClass->allocate) {
2106 newObject = aClass->allocate(aNPP, aClass);
2107 }
2108 else {
2109 newObject = reinterpret_cast<NPObject*>(child::_memalloc(sizeof(NPObject)));
2110 }
2111
2112 if (newObject) {
2113 newObject->_class = aClass;
2114 newObject->referenceCount = 1;
2115 NS_LOG_ADDREF(newObject, 1, "NPObject", sizeof(NPObject));
2116 }
2117
2118 NPObjectData* d = static_cast<PluginModuleChild*>(i->Manager())
2119 ->mObjectMap.PutEntry(newObject);
2120 NS_ASSERTION(!d->instance, "New NPObject already mapped?");
2121 d->instance = i;
2122
2123 return newObject;
2124 }
2125
2126 NPObject*
2127 PluginModuleChild::NPN_RetainObject(NPObject* aNPObj)
2128 {
2129 AssertPluginThread();
2130
2131 #ifdef NS_BUILD_REFCNT_LOGGING
2132 int32_t refCnt =
2133 #endif
2134 PR_ATOMIC_INCREMENT((int32_t*)&aNPObj->referenceCount);
2135 NS_LOG_ADDREF(aNPObj, refCnt, "NPObject", sizeof(NPObject));
2136
2137 return aNPObj;
2138 }
2139
2140 void
2141 PluginModuleChild::NPN_ReleaseObject(NPObject* aNPObj)
2142 {
2143 AssertPluginThread();
2144
2145 NPObjectData* d = current()->mObjectMap.GetEntry(aNPObj);
2146 if (!d) {
2147 NS_ERROR("Releasing object not in mObjectMap?");
2148 return;
2149 }
2150
2151 DeletingObjectEntry* doe = nullptr;
2152 if (d->instance->mDeletingHash) {
2153 doe = d->instance->mDeletingHash->GetEntry(aNPObj);
2154 if (!doe) {
2155 NS_ERROR("An object for a destroyed instance isn't in the instance deletion hash");
2156 return;
2157 }
2158 if (doe->mDeleted)
2159 return;
2160 }
2161
2162 int32_t refCnt = PR_ATOMIC_DECREMENT((int32_t*)&aNPObj->referenceCount);
2163 NS_LOG_RELEASE(aNPObj, refCnt, "NPObject");
2164
2165 if (refCnt == 0) {
2166 DeallocNPObject(aNPObj);
2167 if (doe)
2168 doe->mDeleted = true;
2169 }
2170 return;
2171 }
2172
2173 void
2174 PluginModuleChild::DeallocNPObject(NPObject* aNPObj)
2175 {
2176 if (aNPObj->_class && aNPObj->_class->deallocate) {
2177 aNPObj->_class->deallocate(aNPObj);
2178 } else {
2179 child::_memfree(aNPObj);
2180 }
2181
2182 NPObjectData* d = current()->mObjectMap.GetEntry(aNPObj);
2183 if (d->actor)
2184 d->actor->NPObjectDestroyed();
2185
2186 current()->mObjectMap.RemoveEntry(aNPObj);
2187 }
2188
2189 void
2190 PluginModuleChild::FindNPObjectsForInstance(PluginInstanceChild* instance)
2191 {
2192 NS_ASSERTION(instance->mDeletingHash, "filling null mDeletingHash?");
2193 mObjectMap.EnumerateEntries(CollectForInstance, instance);
2194 }
2195
2196 PLDHashOperator
2197 PluginModuleChild::CollectForInstance(NPObjectData* d, void* userArg)
2198 {
2199 PluginInstanceChild* instance = static_cast<PluginInstanceChild*>(userArg);
2200 if (d->instance == instance) {
2201 NPObject* o = d->GetKey();
2202 instance->mDeletingHash->PutEntry(o);
2203 }
2204 return PL_DHASH_NEXT;
2205 }
2206
2207 NPIdentifier
2208 PluginModuleChild::NPN_GetStringIdentifier(const NPUTF8* aName)
2209 {
2210 PLUGIN_LOG_DEBUG_FUNCTION;
2211 AssertPluginThread();
2212
2213 if (!aName)
2214 return 0;
2215
2216 PluginModuleChild* self = PluginModuleChild::current();
2217 nsDependentCString name(aName);
2218
2219 PluginIdentifierChildString* ident = self->mStringIdentifiers.Get(name);
2220 if (!ident) {
2221 nsCString nameCopy(name);
2222
2223 ident = new PluginIdentifierChildString(nameCopy);
2224 self->SendPPluginIdentifierConstructor(ident, nameCopy, -1, false);
2225 }
2226 ident->MakePermanent();
2227 return ident;
2228 }
2229
2230 void
2231 PluginModuleChild::NPN_GetStringIdentifiers(const NPUTF8** aNames,
2232 int32_t aNameCount,
2233 NPIdentifier* aIdentifiers)
2234 {
2235 PLUGIN_LOG_DEBUG_FUNCTION;
2236 AssertPluginThread();
2237
2238 if (!(aNames && aNameCount > 0 && aIdentifiers)) {
2239 NS_RUNTIMEABORT("Bad input! Headed for a crash!");
2240 }
2241
2242 PluginModuleChild* self = PluginModuleChild::current();
2243
2244 for (int32_t index = 0; index < aNameCount; ++index) {
2245 if (!aNames[index]) {
2246 aIdentifiers[index] = 0;
2247 continue;
2248 }
2249 nsDependentCString name(aNames[index]);
2250 PluginIdentifierChildString* ident = self->mStringIdentifiers.Get(name);
2251 if (!ident) {
2252 nsCString nameCopy(name);
2253
2254 ident = new PluginIdentifierChildString(nameCopy);
2255 self->SendPPluginIdentifierConstructor(ident, nameCopy, -1, false);
2256 }
2257 ident->MakePermanent();
2258 aIdentifiers[index] = ident;
2259 }
2260 }
2261
2262 bool
2263 PluginModuleChild::NPN_IdentifierIsString(NPIdentifier aIdentifier)
2264 {
2265 PLUGIN_LOG_DEBUG_FUNCTION;
2266
2267 PluginIdentifierChild* ident =
2268 static_cast<PluginIdentifierChild*>(aIdentifier);
2269 return ident->IsString();
2270 }
2271
2272 NPIdentifier
2273 PluginModuleChild::NPN_GetIntIdentifier(int32_t aIntId)
2274 {
2275 PLUGIN_LOG_DEBUG_FUNCTION;
2276 AssertPluginThread();
2277
2278 PluginModuleChild* self = PluginModuleChild::current();
2279
2280 PluginIdentifierChildInt* ident = self->mIntIdentifiers.Get(aIntId);
2281 if (!ident) {
2282 nsCString voidString;
2283 voidString.SetIsVoid(true);
2284
2285 ident = new PluginIdentifierChildInt(aIntId);
2286 self->SendPPluginIdentifierConstructor(ident, voidString, aIntId, false);
2287 }
2288 ident->MakePermanent();
2289 return ident;
2290 }
2291
2292 NPUTF8*
2293 PluginModuleChild::NPN_UTF8FromIdentifier(NPIdentifier aIdentifier)
2294 {
2295 PLUGIN_LOG_DEBUG_FUNCTION;
2296
2297 if (static_cast<PluginIdentifierChild*>(aIdentifier)->IsString()) {
2298 return static_cast<PluginIdentifierChildString*>(aIdentifier)->ToString();
2299 }
2300 return nullptr;
2301 }
2302
2303 int32_t
2304 PluginModuleChild::NPN_IntFromIdentifier(NPIdentifier aIdentifier)
2305 {
2306 PLUGIN_LOG_DEBUG_FUNCTION;
2307
2308 if (!static_cast<PluginIdentifierChild*>(aIdentifier)->IsString()) {
2309 return static_cast<PluginIdentifierChildInt*>(aIdentifier)->ToInt();
2310 }
2311 return INT32_MIN;
2312 }
2313
2314 #ifdef OS_WIN
2315 void
2316 PluginModuleChild::EnteredCall()
2317 {
2318 mIncallPumpingStack.AppendElement();
2319 }
2320
2321 void
2322 PluginModuleChild::ExitedCall()
2323 {
2324 NS_ASSERTION(mIncallPumpingStack.Length(), "mismatched entered/exited");
2325 uint32_t len = mIncallPumpingStack.Length();
2326 const IncallFrame& f = mIncallPumpingStack[len - 1];
2327 if (f._spinning)
2328 MessageLoop::current()->SetNestableTasksAllowed(f._savedNestableTasksAllowed);
2329
2330 mIncallPumpingStack.TruncateLength(len - 1);
2331 }
2332
2333 LRESULT CALLBACK
2334 PluginModuleChild::CallWindowProcHook(int nCode, WPARAM wParam, LPARAM lParam)
2335 {
2336 // Trap and reply to anything we recognize as the source of a
2337 // potential send message deadlock.
2338 if (nCode >= 0 &&
2339 (InSendMessageEx(nullptr)&(ISMEX_REPLIED|ISMEX_SEND)) == ISMEX_SEND) {
2340 CWPSTRUCT* pCwp = reinterpret_cast<CWPSTRUCT*>(lParam);
2341 if (pCwp->message == WM_KILLFOCUS) {
2342 // Fix for flash fullscreen window loosing focus. On single
2343 // core systems, sync killfocus events need to be handled
2344 // after the flash fullscreen window procedure processes this
2345 // message, otherwise fullscreen focus will not work correctly.
2346 wchar_t szClass[26];
2347 if (GetClassNameW(pCwp->hwnd, szClass,
2348 sizeof(szClass)/sizeof(char16_t)) &&
2349 !wcscmp(szClass, kFlashFullscreenClass)) {
2350 gDelayFlashFocusReplyUntilEval = true;
2351 }
2352 }
2353 }
2354
2355 return CallNextHookEx(nullptr, nCode, wParam, lParam);
2356 }
2357
2358 LRESULT CALLBACK
2359 PluginModuleChild::NestedInputEventHook(int nCode, WPARAM wParam, LPARAM lParam)
2360 {
2361 PluginModuleChild* self = current();
2362 uint32_t len = self->mIncallPumpingStack.Length();
2363 if (nCode >= 0 && len && !self->mIncallPumpingStack[len - 1]._spinning) {
2364 MessageLoop* loop = MessageLoop::current();
2365 self->SendProcessNativeEventsInInterruptCall();
2366 IncallFrame& f = self->mIncallPumpingStack[len - 1];
2367 f._spinning = true;
2368 f._savedNestableTasksAllowed = loop->NestableTasksAllowed();
2369 loop->SetNestableTasksAllowed(true);
2370 loop->set_os_modal_loop(true);
2371 }
2372
2373 return CallNextHookEx(nullptr, nCode, wParam, lParam);
2374 }
2375
2376 void
2377 PluginModuleChild::SetEventHooks()
2378 {
2379 NS_ASSERTION(!mNestedEventHook,
2380 "mNestedEventHook already setup in call to SetNestedInputEventHook?");
2381 NS_ASSERTION(!mGlobalCallWndProcHook,
2382 "mGlobalCallWndProcHook already setup in call to CallWindowProcHook?");
2383
2384 PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
2385
2386 // WH_MSGFILTER event hook for detecting modal loops in the child.
2387 mNestedEventHook = SetWindowsHookEx(WH_MSGFILTER,
2388 NestedInputEventHook,
2389 nullptr,
2390 GetCurrentThreadId());
2391
2392 // WH_CALLWNDPROC event hook for trapping sync messages sent from
2393 // parent that can cause deadlocks.
2394 mGlobalCallWndProcHook = SetWindowsHookEx(WH_CALLWNDPROC,
2395 CallWindowProcHook,
2396 nullptr,
2397 GetCurrentThreadId());
2398 }
2399
2400 void
2401 PluginModuleChild::ResetEventHooks()
2402 {
2403 PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
2404 if (mNestedEventHook)
2405 UnhookWindowsHookEx(mNestedEventHook);
2406 mNestedEventHook = nullptr;
2407 if (mGlobalCallWndProcHook)
2408 UnhookWindowsHookEx(mGlobalCallWndProcHook);
2409 mGlobalCallWndProcHook = nullptr;
2410 }
2411 #endif
2412
2413 bool
2414 PluginModuleChild::RecvProcessNativeEventsInInterruptCall()
2415 {
2416 PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
2417 #if defined(OS_WIN)
2418 ProcessNativeEventsInInterruptCall();
2419 return true;
2420 #else
2421 NS_RUNTIMEABORT(
2422 "PluginModuleChild::RecvProcessNativeEventsInInterruptCall not implemented!");
2423 return false;
2424 #endif
2425 }
2426
2427 #ifdef MOZ_WIDGET_COCOA
2428 void
2429 PluginModuleChild::ProcessNativeEvents() {
2430 CallProcessSomeEvents();
2431 }
2432 #endif
2433
2434 bool
2435 PluginModuleChild::AnswerGeckoGetProfile(nsCString* aProfile) {
2436 char* profile = profiler_get_profile();
2437 if (profile != nullptr) {
2438 *aProfile = nsCString(profile, strlen(profile));
2439 free(profile);
2440 } else {
2441 *aProfile = nsCString("", 0);
2442 }
2443 return true;
2444 }
2445

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial