plevent.c@ 101898

Last change on this file since 101898 was 101898, checked in by vboxsync, 17 months ago
libs/xpcom: Rmove unused code, bugref:10545
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.6 KB

Line
1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2	/* *** BEGIN LICENSE BLOCK ***
3	* Version: MPL 1.1/GPL 2.0/LGPL 2.1
4	*
5	* The contents of this file are subject to the Mozilla Public License Version
6	* 1.1 (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	* http://www.mozilla.org/MPL/
9	*
10	* Software distributed under the License is distributed on an "AS IS" basis,
11	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12	* for the specific language governing rights and limitations under the
13	* License.
14	*
15	* The Original Code is mozilla.org Code.
16	*
17	* The Initial Developer of the Original Code is
18	* Netscape Communications Corporation.
19	* Portions created by the Initial Developer are Copyright (C) 1998
20	* the Initial Developer. All Rights Reserved.
21	*
22	* Contributor(s):
23	*
24	* Alternatively, the contents of this file may be used under the terms of
25	* either of the GNU General Public License Version 2 or later (the "GPL"),
26	* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27	* in which case the provisions of the GPL or the LGPL are applicable instead
28	* of those above. If you wish to allow use of your version of this file only
29	* under the terms of either the GPL or the LGPL, and not to allow others to
30	* use your version of this file under the terms of the MPL, indicate your
31	* decision by deleting the provisions above and replace them with the notice
32	* and other provisions required by the GPL or the LGPL. If you do not delete
33	* the provisions above, a recipient may use your version of this file under
34	* the terms of any one of the MPL, the GPL or the LGPL.
35	*
36	* *** END LICENSE BLOCK *** */
37
38	#include "nspr.h"
39	#include "plevent.h"
40
41	#include <errno.h>
42	#include <stddef.h>
43	#include <unistd.h>
44	/* for fcntl */
45	#include <sys/types.h>
46	#include <fcntl.h>
47
48	#if defined(XP_MACOSX)
49	# include <CoreFoundation/CoreFoundation.h>
50	#endif
51
52	#include "private/pprthred.h"
53
54	static PRLogModuleInfo *event_lm = NULL;
55
56	/*******************************************************************************
57	* Private Stuff
58	******************************************************************************/
59
60	/*
61	** EventQueueType -- Defines notification type for an event queue
62	**
63	*/
64	typedef enum {
65	EventQueueIsNative = 1,
66	EventQueueIsMonitored = 2
67	} EventQueueType;
68
69
70	struct PLEventQueue {
71	const char* name;
72	PRCList queue;
73	PRMonitor* monitor;
74	PRThread* handlerThread;
75	EventQueueType type;
76	PRPackedBool processingEvents;
77	PRPackedBool notified;
78
79	#if defined(XP_UNIX) && !defined(XP_MACOSX)
80	PRInt32 eventPipe[2];
81	PLGetEventIDFunc idFunc;
82	void* idFuncClosure;
83	#elif defined(XP_MACOSX)
84	CFRunLoopSourceRef mRunLoopSource;
85	CFRunLoopRef mMainRunLoop;
86	CFStringRef mRunLoopModeStr; /* vbox */
87	#endif
88	};
89
90	#define PR_EVENT_PTR(_qp) \
91	((PLEvent) ((char) (_qp) - offsetof(PLEvent, link)))
92
93	static PRStatus _pl_SetupNativeNotifier(PLEventQueue* self);
94	static void _pl_CleanupNativeNotifier(PLEventQueue* self);
95	static PRStatus _pl_NativeNotify(PLEventQueue* self);
96	static PRStatus _pl_AcknowledgeNativeNotify(PLEventQueue* self);
97	static void _md_CreateEventQueue( PLEventQueue *eventQueue );
98	static PRInt32 _pl_GetEventCount(PLEventQueue* self);
99
100
101	/*******************************************************************************
102	* Event Queue Operations
103	******************************************************************************/
104
105	/*
106	** _pl_CreateEventQueue() -- Create the event queue
107	**
108	**
109	*/
110	static PLEventQueue * _pl_CreateEventQueue(const char *name,
111	PRThread *handlerThread,
112	EventQueueType qtype)
113	{
114	PRStatus err;
115	PLEventQueue* self = NULL;
116	PRMonitor* mon = NULL;
117
118	if (event_lm == NULL)
119	event_lm = PR_NewLogModule("event");
120
121	self = PR_NEWZAP(PLEventQueue);
122	if (self == NULL) return NULL;
123
124	mon = PR_NewNamedMonitor(name);
125	if (mon == NULL) goto error;
126
127	self->name = name;
128	self->monitor = mon;
129	self->handlerThread = handlerThread;
130	self->processingEvents = PR_FALSE;
131	self->type = qtype;
132	self->notified = PR_FALSE;
133
134	PR_INIT_CLIST(&self->queue);
135	if ( qtype == EventQueueIsNative ) {
136	err = _pl_SetupNativeNotifier(self);
137	if (err) goto error;
138	_md_CreateEventQueue( self );
139	}
140	return self;
141
142	error:
143	if (mon != NULL)
144	PR_DestroyMonitor(mon);
145	PR_DELETE(self);
146	return NULL;
147	}
148
149	PR_IMPLEMENT(PLEventQueue*)
150	PL_CreateEventQueue(const char* name, PRThread* handlerThread)
151	{
152	return( _pl_CreateEventQueue( name, handlerThread, EventQueueIsNative ));
153	}
154
155	PR_EXTERN(PLEventQueue *)
156	PL_CreateNativeEventQueue(const char name, PRThread handlerThread)
157	{
158	return( _pl_CreateEventQueue( name, handlerThread, EventQueueIsNative ));
159	}
160
161	PR_EXTERN(PLEventQueue *)
162	PL_CreateMonitoredEventQueue(const char name, PRThread handlerThread)
163	{
164	return( _pl_CreateEventQueue( name, handlerThread, EventQueueIsMonitored ));
165	}
166
167	PR_IMPLEMENT(PRMonitor*)
168	PL_GetEventQueueMonitor(PLEventQueue* self)
169	{
170	return self->monitor;
171	}
172
173	static void PR_CALLBACK
174	_pl_destroyEvent(PLEvent* event, void* data, PLEventQueue* queue)
175	{
176	PL_DequeueEvent(event, queue);
177	PL_DestroyEvent(event);
178	}
179
180	PR_IMPLEMENT(void)
181	PL_DestroyEventQueue(PLEventQueue* self)
182	{
183	PR_EnterMonitor(self->monitor);
184
185	/* destroy undelivered events */
186	PL_MapEvents(self, _pl_destroyEvent, NULL);
187
188	if ( self->type == EventQueueIsNative )
189	_pl_CleanupNativeNotifier(self);
190
191	/* destroying the monitor also destroys the name */
192	PR_ExitMonitor(self->monitor);
193	PR_DestroyMonitor(self->monitor);
194	PR_DELETE(self);
195
196	}
197
198	PR_IMPLEMENT(PRStatus)
199	PL_PostEvent(PLEventQueue* self, PLEvent* event)
200	{
201	PRStatus err = PR_SUCCESS;
202	PRMonitor* mon;
203
204	if (self == NULL)
205	return PR_FAILURE;
206
207	mon = self->monitor;
208	PR_EnterMonitor(mon);
209
210	#if defined(XP_UNIX) && !defined(XP_MACOSX)
211	if (self->idFunc && event)
212	event->id = self->idFunc(self->idFuncClosure);
213	#endif
214
215	/* insert event into thread's event queue: */
216	if (event != NULL) {
217	PR_APPEND_LINK(&event->link, &self->queue);
218	}
219
220	if (self->type == EventQueueIsNative && !self->notified) {
221	err = _pl_NativeNotify(self);
222
223	if (err != PR_SUCCESS)
224	goto error;
225
226	self->notified = PR_TRUE;
227	}
228
229	/*
230	* This may fall on deaf ears if we're really notifying the native
231	* thread, and no one has called PL_WaitForEvent (or PL_EventLoop):
232	*/
233	err = PR_Notify(mon);
234
235	error:
236	PR_ExitMonitor(mon);
237	return err;
238	}
239
240	PR_IMPLEMENT(void*)
241	PL_PostSynchronousEvent(PLEventQueue* self, PLEvent* event)
242	{
243	void* result;
244
245	if (self == NULL)
246	return NULL;
247
248	PR_ASSERT(event != NULL);
249
250	if (PR_GetCurrentThread() == self->handlerThread) {
251	/* Handle the case where the thread requesting the event handling
252	* is also the thread that's supposed to do the handling. */
253	result = event->handler(event);
254	}
255	else {
256	int i, entryCount;
257
258	event->lock = PR_NewLock();
259	if (!event->lock) {
260	return NULL;
261	}
262	event->condVar = PR_NewCondVar(event->lock);
263	if(!event->condVar) {
264	PR_DestroyLock(event->lock);
265	event->lock = NULL;
266	return NULL;
267	}
268
269	PR_Lock(event->lock);
270
271	entryCount = PR_GetMonitorEntryCount(self->monitor);
272
273	event->synchronousResult = (void*)PR_TRUE;
274
275	PL_PostEvent(self, event);
276
277	/* We need temporarily to give up our event queue monitor if
278	we're holding it, otherwise, the thread we're going to wait
279	for notification from won't be able to enter it to process
280	the event. */
281	if (entryCount) {
282	for (i = 0; i < entryCount; i++)
283	PR_ExitMonitor(self->monitor);
284	}
285
286	event->handled = PR_FALSE;
287
288	while (!event->handled) {
289	/* wait for event to be handled or destroyed */
290	PR_WaitCondVar(event->condVar, PR_INTERVAL_NO_TIMEOUT);
291	}
292
293	if (entryCount) {
294	for (i = 0; i < entryCount; i++)
295	PR_EnterMonitor(self->monitor);
296	}
297
298	result = event->synchronousResult;
299	event->synchronousResult = NULL;
300	PR_Unlock(event->lock);
301	}
302
303	/* For synchronous events, they're destroyed here on the caller's
304	thread before the result is returned. See PL_HandleEvent. */
305	PL_DestroyEvent(event);
306
307	return result;
308	}
309
310	PR_IMPLEMENT(PLEvent*)
311	PL_GetEvent(PLEventQueue* self)
312	{
313	PLEvent* event = NULL;
314	PRStatus err = PR_SUCCESS;
315
316	if (self == NULL)
317	return NULL;
318
319	PR_EnterMonitor(self->monitor);
320
321	if (!PR_CLIST_IS_EMPTY(&self->queue)) {
322	if ( self->type == EventQueueIsNative &&
323	self->notified &&
324	!self->processingEvents &&
325	0 == _pl_GetEventCount(self) )
326	{
327	err = _pl_AcknowledgeNativeNotify(self);
328	self->notified = PR_FALSE;
329	}
330	if (err)
331	goto done;
332
333	/* then grab the event and return it: */
334	event = PR_EVENT_PTR(self->queue.next);
335	PR_REMOVE_AND_INIT_LINK(&event->link);
336	}
337
338	done:
339	PR_ExitMonitor(self->monitor);
340	return event;
341	}
342
343	PR_IMPLEMENT(PRBool)
344	PL_EventAvailable(PLEventQueue* self)
345	{
346	PRBool result = PR_FALSE;
347
348	if (self == NULL)
349	return PR_FALSE;
350
351	PR_EnterMonitor(self->monitor);
352
353	if (!PR_CLIST_IS_EMPTY(&self->queue))
354	result = PR_TRUE;
355
356	PR_ExitMonitor(self->monitor);
357	return result;
358	}
359
360	PR_IMPLEMENT(void)
361	PL_MapEvents(PLEventQueue* self, PLEventFunProc fun, void* data)
362	{
363	PRCList* qp;
364
365	if (self == NULL)
366	return;
367
368	PR_EnterMonitor(self->monitor);
369	qp = self->queue.next;
370	while (qp != &self->queue) {
371	PLEvent* event = PR_EVENT_PTR(qp);
372	qp = qp->next;
373	(*fun)(event, data, self);
374	}
375	PR_ExitMonitor(self->monitor);
376	}
377
378	static void PR_CALLBACK
379	_pl_DestroyEventForOwner(PLEvent* event, void* owner, PLEventQueue* queue)
380	{
381	PR_ASSERT(PR_GetMonitorEntryCount(queue->monitor) > 0);
382	if (event->owner == owner) {
383	PR_LOG(event_lm, PR_LOG_DEBUG,
384	("$$$ \tdestroying event %0x for owner %0x", event, owner));
385	PL_DequeueEvent(event, queue);
386
387	if (event->synchronousResult == (void*)PR_TRUE) {
388	PR_Lock(event->lock);
389	event->synchronousResult = NULL;
390	event->handled = PR_TRUE;
391	PR_NotifyCondVar(event->condVar);
392	PR_Unlock(event->lock);
393	}
394	else {
395	PL_DestroyEvent(event);
396	}
397	}
398	else {
399	PR_LOG(event_lm, PR_LOG_DEBUG,
400	("$$$ \tskipping event %0x for owner %0x", event, owner));
401	}
402	}
403
404	PR_IMPLEMENT(void)
405	PL_RevokeEvents(PLEventQueue* self, void* owner)
406	{
407	if (self == NULL)
408	return;
409
410	PR_LOG(event_lm, PR_LOG_DEBUG,
411	("$$$ revoking events for owner %0x", owner));
412
413	/*
414	** First we enter the monitor so that no one else can post any events
415	** to the queue:
416	*/
417	PR_EnterMonitor(self->monitor);
418	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ owner %0x, entered monitor", owner));
419
420	/*
421	** Discard any pending events for this owner:
422	*/
423	PL_MapEvents(self, _pl_DestroyEventForOwner, owner);
424
425	#ifdef DEBUG
426	{
427	PRCList* qp = self->queue.next;
428	while (qp != &self->queue) {
429	PLEvent* event = PR_EVENT_PTR(qp);
430	qp = qp->next;
431	PR_ASSERT(event->owner != owner);
432	}
433	}
434	#endif /* DEBUG */
435
436	PR_ExitMonitor(self->monitor);
437
438	PR_LOG(event_lm, PR_LOG_DEBUG,
439	("$$$ revoking events for owner %0x", owner));
440	}
441
442	static PRInt32
443	_pl_GetEventCount(PLEventQueue* self)
444	{
445	PRCList* node;
446	PRInt32 count = 0;
447
448	PR_EnterMonitor(self->monitor);
449	node = PR_LIST_HEAD(&self->queue);
450	while (node != &self->queue) {
451	count++;
452	node = PR_NEXT_LINK(node);
453	}
454	PR_ExitMonitor(self->monitor);
455
456	return count;
457	}
458
459	PR_IMPLEMENT(void)
460	PL_ProcessPendingEvents(PLEventQueue* self)
461	{
462	PRInt32 count;
463
464	if (self == NULL)
465	return;
466
467
468	PR_EnterMonitor(self->monitor);
469
470	if (self->processingEvents) {
471	_pl_AcknowledgeNativeNotify(self);
472	self->notified = PR_FALSE;
473	PR_ExitMonitor(self->monitor);
474	return;
475	}
476	self->processingEvents = PR_TRUE;
477
478	/* Only process the events that are already in the queue, and
479	* not any new events that get added. Do this by counting the
480	* number of events currently in the queue
481	*/
482	count = _pl_GetEventCount(self);
483	PR_ExitMonitor(self->monitor);
484
485	while (count-- > 0) {
486	PLEvent* event = PL_GetEvent(self);
487	if (event == NULL)
488	break;
489
490	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ processing event"));
491	PL_HandleEvent(event);
492	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ done processing event"));
493	}
494
495	PR_EnterMonitor(self->monitor);
496
497	if (self->type == EventQueueIsNative) {
498	count = _pl_GetEventCount(self);
499
500	if (count <= 0) {
501	_pl_AcknowledgeNativeNotify(self);
502	self->notified = PR_FALSE;
503	}
504	else {
505	_pl_NativeNotify(self);
506	self->notified = PR_TRUE;
507	}
508
509	}
510	self->processingEvents = PR_FALSE;
511
512	PR_ExitMonitor(self->monitor);
513	}
514
515	/*******************************************************************************
516	* Event Operations
517	******************************************************************************/
518
519	PR_IMPLEMENT(void)
520	PL_InitEvent(PLEvent* self, void* owner,
521	PLHandleEventProc handler,
522	PLDestroyEventProc destructor)
523	{
524	PR_INIT_CLIST(&self->link);
525	self->handler = handler;
526	self->destructor = destructor;
527	self->owner = owner;
528	self->synchronousResult = NULL;
529	self->handled = PR_FALSE;
530	self->lock = NULL;
531	self->condVar = NULL;
532	#if defined(XP_UNIX) && !defined(XP_MACOSX)
533	self->id = 0;
534	#endif
535	}
536
537	PR_IMPLEMENT(void*)
538	PL_GetEventOwner(PLEvent* self)
539	{
540	return self->owner;
541	}
542
543	PR_IMPLEMENT(void)
544	PL_HandleEvent(PLEvent* self)
545	{
546	void* result;
547	if (self == NULL)
548	return;
549
550	/* This event better not be on an event queue anymore. */
551	PR_ASSERT(PR_CLIST_IS_EMPTY(&self->link));
552
553	result = self->handler(self);
554	if (NULL != self->synchronousResult) {
555	PR_Lock(self->lock);
556	self->synchronousResult = result;
557	self->handled = PR_TRUE;
558	PR_NotifyCondVar(self->condVar);
559	PR_Unlock(self->lock);
560	}
561	else {
562	/* For asynchronous events, they're destroyed by the event-handler
563	thread. See PR_PostSynchronousEvent. */
564	PL_DestroyEvent(self);
565	}
566	}
567
568	PR_IMPLEMENT(void)
569	PL_DestroyEvent(PLEvent* self)
570	{
571	if (self == NULL)
572	return;
573
574	/* This event better not be on an event queue anymore. */
575	PR_ASSERT(PR_CLIST_IS_EMPTY(&self->link));
576
577	if(self->condVar)
578	PR_DestroyCondVar(self->condVar);
579	if(self->lock)
580	PR_DestroyLock(self->lock);
581
582	self->destructor(self);
583	}
584
585	PR_IMPLEMENT(void)
586	PL_DequeueEvent(PLEvent* self, PLEventQueue* queue)
587	{
588	if (self == NULL)
589	return;
590
591	/* Only the owner is allowed to dequeue events because once the
592	client has put it in the queue, they have no idea whether it's
593	been processed and destroyed or not. */
594
595	PR_ASSERT(queue->handlerThread == PR_GetCurrentThread());
596
597	PR_EnterMonitor(queue->monitor);
598
599	PR_ASSERT(!PR_CLIST_IS_EMPTY(&self->link));
600
601	#if 0
602	/* I do not think that we need to do this anymore.
603	if we do not acknowledge and this is the only
604	only event in the queue, any calls to process
605	the eventQ will be effective noop.
606	*/
607	if (queue->type == EventQueueIsNative)
608	_pl_AcknowledgeNativeNotify(queue);
609	#endif
610
611	PR_REMOVE_AND_INIT_LINK(&self->link);
612
613	PR_ExitMonitor(queue->monitor);
614	}
615
616	PR_IMPLEMENT(void)
617	PL_FavorPerformanceHint(PRBool favorPerformanceOverEventStarvation,
618	PRUint32 starvationDelay)
619	{
620	}
621
622	/*******************************************************************************
623	* Pure Event Queues
624	*
625	* For when you're only processing PLEvents and there is no native
626	* select, thread messages, or AppleEvents.
627	******************************************************************************/
628
629	PR_IMPLEMENT(PLEvent*)
630	PL_WaitForEvent(PLEventQueue* self)
631	{
632	PLEvent* event;
633	PRMonitor* mon;
634
635	if (self == NULL)
636	return NULL;
637
638	mon = self->monitor;
639	PR_EnterMonitor(mon);
640
641	while ((event = PL_GetEvent(self)) == NULL) {
642	PRStatus err;
643	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ waiting for event"));
644	err = PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
645	if ((err == PR_FAILURE)
646	&& (PR_PENDING_INTERRUPT_ERROR == PR_GetError())) break;
647	}
648
649	PR_ExitMonitor(mon);
650	return event;
651	}
652
653	PR_IMPLEMENT(void)
654	PL_EventLoop(PLEventQueue* self)
655	{
656	if (self == NULL)
657	return;
658
659	while (PR_TRUE) {
660	PLEvent* event = PL_WaitForEvent(self);
661	if (event == NULL) {
662	/* This can only happen if the current thread is interrupted */
663	return;
664	}
665
666	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ processing event"));
667	PL_HandleEvent(event);
668	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ done processing event"));
669	}
670	}
671
672	/*******************************************************************************
673	* Native Event Queues
674	*
675	* For when you need to call select, or WaitNextEvent, and yet also want
676	* to handle PLEvents.
677	******************************************************************************/
678
679	static PRStatus
680	_pl_SetupNativeNotifier(PLEventQueue* self)
681	{
682	#if defined(XP_UNIX) && !defined(XP_MACOSX)
683	int err;
684	int flags;
685
686	self->idFunc = 0;
687	self->idFuncClosure = 0;
688
689	err = pipe(self->eventPipe);
690	if (err != 0) {
691	return PR_FAILURE;
692	}
693	#ifdef VBOX
694	fcntl(self->eventPipe[0], F_SETFD, FD_CLOEXEC);
695	fcntl(self->eventPipe[1], F_SETFD, FD_CLOEXEC);
696	#endif
697
698	/* make the pipe nonblocking */
699	flags = fcntl(self->eventPipe[0], F_GETFL, 0);
700	if (flags == -1) {
701	goto failed;
702	}
703	err = fcntl(self->eventPipe[0], F_SETFL, flags \| O_NONBLOCK);
704	if (err == -1) {
705	goto failed;
706	}
707	flags = fcntl(self->eventPipe[1], F_GETFL, 0);
708	if (flags == -1) {
709	goto failed;
710	}
711	err = fcntl(self->eventPipe[1], F_SETFL, flags \| O_NONBLOCK);
712	if (err == -1) {
713	goto failed;
714	}
715	return PR_SUCCESS;
716
717	failed:
718	close(self->eventPipe[0]);
719	close(self->eventPipe[1]);
720	return PR_FAILURE;
721	#else
722	return PR_SUCCESS;
723	#endif
724	}
725
726	static void
727	_pl_CleanupNativeNotifier(PLEventQueue* self)
728	{
729	#if defined(XP_UNIX) && !defined(XP_MACOSX)
730	close(self->eventPipe[0]);
731	close(self->eventPipe[1]);
732	#elif defined(MAC_USE_CFRUNLOOPSOURCE)
733
734	CFRunLoopRemoveSource(self->mMainRunLoop, self->mRunLoopSource, kCFRunLoopCommonModes);
735	CFRunLoopRemoveSource(self->mMainRunLoop, self->mRunLoopSource, self->mRunLoopModeStr); /* vbox */
736	CFRelease(self->mRunLoopSource);
737	CFRelease(self->mMainRunLoop);
738	CFRelease(self->mRunLoopModeStr); /* vbox */
739	#endif
740	}
741
742	#if defined(XP_UNIX) && !defined(XP_MACOSX)
743
744	static PRStatus
745	_pl_NativeNotify(PLEventQueue* self)
746	{
747	#define NOTIFY_TOKEN 0xFA
748	PRInt32 count;
749	unsigned char buf[] = { NOTIFY_TOKEN };
750
751	# ifdef VBOX
752	/* Don't write two chars, because we'll only acknowledge one and that'll
753	cause trouble for anyone selecting/polling on the read descriptor. */
754	if (self->notified)
755	return PR_SUCCESS;
756	# endif
757
758	PR_LOG(event_lm, PR_LOG_DEBUG,
759	("_pl_NativeNotify: self=%p",
760	self));
761	count = write(self->eventPipe[1], buf, 1);
762	if (count == 1)
763	return PR_SUCCESS;
764	if (count == -1 && (errno == EAGAIN \|\| errno == EWOULDBLOCK))
765	return PR_SUCCESS;
766	return PR_FAILURE;
767	}/* --- end _pl_NativeNotify() --- */
768	#endif /* defined(XP_UNIX) && !defined(XP_MACOSX) */
769
770	#if defined(XP_MACOSX)
771	static PRStatus
772	_pl_NativeNotify(PLEventQueue* self)
773	{
774	CFRunLoopSourceSignal(self->mRunLoopSource);
775	CFRunLoopWakeUp(self->mMainRunLoop);
776	return PR_SUCCESS;
777	}
778	#endif /* defined(XP_MACOSX) */
779
780	static PRStatus
781	_pl_AcknowledgeNativeNotify(PLEventQueue* self)
782	{
783	#if defined(XP_UNIX) && !defined(XP_MACOSX)
784
785	PRInt32 count;
786	unsigned char c;
787	PR_LOG(event_lm, PR_LOG_DEBUG,
788	("_pl_AcknowledgeNativeNotify: self=%p",
789	self));
790	/* consume the byte NativeNotify put in our pipe: */
791	count = read(self->eventPipe[0], &c, 1);
792	if ((count == 1) && (c == NOTIFY_TOKEN))
793	return PR_SUCCESS;
794	if ((count == -1) && ((errno == EAGAIN) \|\| (errno == EWOULDBLOCK)))
795	return PR_SUCCESS;
796	return PR_FAILURE;
797	#elif defined(XP_MACOSX) /* vbox */
798	/* vbox */
799	CFRunLoopRunInMode(self->mRunLoopModeStr, 0.0, 1); /* vbox */
800	return PR_SUCCESS; /* vbox */
801	#else
802	/* nothing to do on the other platforms */
803	return PR_SUCCESS;
804	#endif
805	}
806
807	PR_IMPLEMENT(PRInt32)
808	PL_GetEventQueueSelectFD(PLEventQueue* self)
809	{
810	if (self == NULL)
811	return -1;
812
813	#if defined(XP_UNIX) && !defined(XP_MACOSX)
814	return self->eventPipe[0];
815	#else
816	return -1; /* other platforms don't handle this (yet) */
817	#endif
818	}
819
820	PR_IMPLEMENT(PRBool)
821	PL_IsQueueOnCurrentThread( PLEventQueue *queue )
822	{
823	PRThread *me = PR_GetCurrentThread();
824	return me == queue->handlerThread;
825	}
826
827	PR_EXTERN(PRBool)
828	PL_IsQueueNative(PLEventQueue *queue)
829	{
830	return queue->type == EventQueueIsNative ? PR_TRUE : PR_FALSE;
831	}
832
833	#if defined(XP_UNIX) && !defined(XP_MACOSX)
834	/*
835	** _md_CreateEventQueue() -- ModelDependent initializer
836	*/
837	static void _md_CreateEventQueue( PLEventQueue *eventQueue )
838	{
839	/* there's really nothing special to do here,
840	** the guts of the unix stuff is in the setupnativenotify
841	** and related functions.
842	*/
843	return;
844	} /* end _md_CreateEventQueue() */
845	#endif /* defined(XP_UNIX) && !defined(XP_MACOSX) */
846
847	static void _md_EventReceiverProc(void *info)
848	{
849	PLEventQueue queue = (PLEventQueue)info;
850	PL_ProcessPendingEvents(queue);
851	}
852
853	#if defined(XP_MACOSX)
854	static void _md_CreateEventQueue( PLEventQueue *eventQueue )
855	{
856	CFRunLoopSourceContext sourceContext = { 0 };
857	sourceContext.version = 0;
858	sourceContext.info = (void*)eventQueue;
859	sourceContext.perform = _md_EventReceiverProc;
860
861	/* make a run loop source */
862	eventQueue->mRunLoopSource = CFRunLoopSourceCreate(kCFAllocatorDefault, 0 /* order */, &sourceContext);
863	PR_ASSERT(eventQueue->mRunLoopSource);
864
865	eventQueue->mMainRunLoop = CFRunLoopGetCurrent();
866	CFRetain(eventQueue->mMainRunLoop);
867
868	/* and add it to the run loop */
869	CFRunLoopAddSource(eventQueue->mMainRunLoop, eventQueue->mRunLoopSource, kCFRunLoopCommonModes);
870
871	/* Add it again but with a unique mode name so we can acknowledge it
872	without processing any other message sources. */
873	{ /* vbox */
874	char szModeName[80]; /* vbox */
875	snprintf(szModeName, sizeof(szModeName), "VBoxXPCOMQueueMode-%p", eventQueue); /* vbox */
876	eventQueue->mRunLoopModeStr = CFStringCreateWithCString(kCFAllocatorDefault, /* vbox */
877	szModeName, kCFStringEncodingASCII); /* vbox */
878	CFRunLoopAddSource(eventQueue->mMainRunLoop, /* vbox */
879	eventQueue->mRunLoopSource, eventQueue->mRunLoopModeStr); /* vbox */
880	} /* vbox */
881	} /* end _md_CreateEventQueue() */
882	#endif /* defined(XP_MACOSX) */
883
884	/* extra functions for unix */
885
886	#if defined(XP_UNIX) && !defined(XP_MACOSX)
887
888	PR_IMPLEMENT(PRInt32)
889	PL_ProcessEventsBeforeID(PLEventQueue *aSelf, unsigned long aID)
890	{
891	PRInt32 count = 0;
892	PRInt32 fullCount;
893
894	if (aSelf == NULL)
895	return -1;
896
897	PR_EnterMonitor(aSelf->monitor);
898
899	if (aSelf->processingEvents) {
900	PR_ExitMonitor(aSelf->monitor);
901	return 0;
902	}
903
904	aSelf->processingEvents = PR_TRUE;
905
906	/* Only process the events that are already in the queue, and
907	* not any new events that get added. Do this by counting the
908	* number of events currently in the queue
909	*/
910	fullCount = _pl_GetEventCount(aSelf);
911	PR_LOG(event_lm, PR_LOG_DEBUG,
912	("$$$ fullCount is %d id is %ld\n", fullCount, aID));
913
914	if (fullCount == 0) {
915	aSelf->processingEvents = PR_FALSE;
916	PR_ExitMonitor(aSelf->monitor);
917	return 0;
918	}
919
920	PR_ExitMonitor(aSelf->monitor);
921
922	while (fullCount-- > 0) {
923	/* peek at the next event */
924	PLEvent *event;
925	event = PR_EVENT_PTR(aSelf->queue.next);
926	if (event == NULL)
927	break;
928	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ processing event %ld\n",
929	event->id));
930	if (event->id >= aID) {
931	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ skipping event and breaking"));
932	break;
933	}
934
935	event = PL_GetEvent(aSelf);
936	PL_HandleEvent(event);
937	PR_LOG(event_lm, PR_LOG_DEBUG, ("$$$ done processing event"));
938	count++;
939	}
940
941	PR_EnterMonitor(aSelf->monitor);
942
943	/* if full count still had items left then there's still items left
944	in the queue. Let the native notify token stay. */
945
946	if (aSelf->type == EventQueueIsNative) {
947	fullCount = _pl_GetEventCount(aSelf);
948
949	if (fullCount <= 0) {
950	_pl_AcknowledgeNativeNotify(aSelf);
951	aSelf->notified = PR_FALSE;
952	}
953	}
954
955	aSelf->processingEvents = PR_FALSE;
956
957	PR_ExitMonitor(aSelf->monitor);
958
959	return count;
960	}
961
962	PR_IMPLEMENT(void)
963	PL_RegisterEventIDFunc(PLEventQueue *aSelf, PLGetEventIDFunc aFunc,
964	void *aClosure)
965	{
966	aSelf->idFunc = aFunc;
967	aSelf->idFuncClosure = aClosure;
968	}
969
970	PR_IMPLEMENT(void)
971	PL_UnregisterEventIDFunc(PLEventQueue *aSelf)
972	{
973	aSelf->idFunc = 0;
974	aSelf->idFuncClosure = 0;
975	}
976
977	#endif /* defined(XP_UNIX) && !defined(XP_MACOSX) */
978
979	/* --- end plevent.c --- */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/xpcom18a4/xpcom/threads/plevent.c@ 101898

Download in other formats: