Changeset 22687 in vbox for trunk/src/libs

Timestamp:

Sep 2, 2009 12:25:29 AM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

51800

Message:

VBoxPython/darwin: Re-implemented PyXPCOMMethod_WaitForEvents for darwin.

File:

• trunk/src/libs/xpcom18a4/python/src/module/_xpcom.cpp (modified) (12 diffs)

trunk/src/libs/xpcom18a4/python/src/module/_xpcom.cpp

@@ -496 +496 @@
 static nsIEventQueue* g_mainEventQ = nsnull;
 
-static PyObject* 
+# ifdef RT_OS_DARWIN
+#  include <iprt/time.h>
+#  include <iprt/thread.h>
+#  include <iprt/err.h>
+#  include <CarbonEvents.h>
+
+// Wrapper that checks if the queue has pending events.
+DECLINLINE(bool)
+hasEventQueuePendingEvents(nsIEventQueue *pQueue)
+{
+        PRBool fHasEvents = PR_FALSE;
+        nsresult rc = pQueue->PendingEvents(&fHasEvents);
+        return NS_SUCCEEDED(rc) && fHasEvents ? true : false;
+}
+
+// Wrapper that checks if the queue has pending events.
+DECLINLINE(bool)
+isEventQueueNative(nsIEventQueue *pQueue)
+{
+        PRBool fIsNative = PR_FALSE;
+        nsresult rc = pQueue->IsQueueNative(&fIsNative);
+        return NS_SUCCEEDED(rc) && fIsNative ? true : false;
+}
+
+
+// Common fallback for waiting (and maybe processing) events. Caller process
+// any pending events when 0 is returned.
+static nsresult
+waitForEventsCommonFallback(nsIEventQueue *pQueue, PRInt32 cMsTimeout)
+{
+        if (cMsTimeout < 0) {
+                // WaitForEvent probably does the trick here.
+                PLEvent *pEvent = NULL;
+                nsresult rc = -1;
+                Py_BEGIN_ALLOW_THREADS;
+                rc = pQueue->WaitForEvent(&pEvent);
+                Py_END_ALLOW_THREADS;
+                if (NS_SUCCEEDED(rc)) {
+                        pQueue->HandleEvent(pEvent);
+                        return 0;
+                }
+        } else {
+                // Poll until time out or event is encountered. We have
+                // no other choice here.
+                uint64_t const StartMillTS = RTTimeMilliTS();
+                for (;;)
+                {
+                        // Any pending events?
+                        if (hasEventQueuePendingEvents(pQueue))
+                                return 0;
+
+                        // Work any native per-thread event loops for good measure.
+#  ifdef RT_OS_DARWIN
+                        RunCurrentEventLoop(0.0005 /*sec*/);
+#  endif
+
+                        // Any pending events?
+                        if (hasEventQueuePendingEvents(pQueue))
+                                return 0;
+
+                        // Timed out?
+                        uint64_t cMsElapsed = RTTimeMilliTS() - StartMillTS;
+                        if (cMsElapsed > (uint32_t)cMsTimeout)
+                                break;
+
+                        // Sleep a bit; return 0 if interrupt (see the select code edition).
+                        uint32_t cMsLeft = (uint32_t)cMsTimeout - (uint32_t)cMsElapsed;
+                        int rc = RTThreadSleep(RT_MIN(cMsLeft, 250));
+                        if (rc == VERR_INTERRUPTED)
+                                return 0;
+                }
+        }
+
+        return 1;
+}
+
+
+// Takes care of the waiting on darwin. Caller process any pending events when
+// 0 is returned.
+static nsresult
+waitForEventsOnDarwin(nsIEventQueue *pQueue, PRInt32 cMsTimeout)
+{
+        // This deals with the common case where the caller is the main
+        // application thread and the queue is a native one.
+        if (    isEventQueueNative(pQueue)
+            &&  GetCurrentEventLoop() == GetMainEventLoop()
+        ) {
+                OSStatus     orc       = -1;
+                EventTimeout rdTimeout = cMsTimeout < 0
+                                       ? kEventDurationForever
+                                       : (double)cMsTimeout / 1000;
+                Py_BEGIN_ALLOW_THREADS;
+                orc = RunCurrentEventLoop(rdTimeout);
+                Py_END_ALLOW_THREADS;
+                if (!orc || orc == eventLoopQuitErr)
+                        return 0;
+
+                if (orc != eventLoopTimedOutErr) {
+                        NS_WARNING("Unexpected status code from RunCurrentEventLoop");
+                        RTThreadSleep(1); // throttle
+                }
+
+                return hasEventQueuePendingEvents(pQueue) ? 0 : 1;
+        }
+
+        // All native queus are driven by the main application loop... Use the
+        // fallback for now.
+        return waitForEventsCommonFallback(pQueue, cMsTimeout);
+}
+
+# endif /* RT_OS_DARWIN */
+
+static PyObject*
 PyXPCOMMethod_WaitForEvents(PyObject *self, PyObject *args)
 {
@@ -505 +617 @@
 
   nsIEventQueue* q = g_mainEventQ;
+  if (q == nsnull)
+    return NULL;
+
+  NS_WARN_IF_FALSE(isEventQueueNative(q), "The event queue must be native!");
+
+  PRInt32 result = 0;
+# ifdef RT_OS_DARWIN
+  if (aTimeout != 0 && !hasEventQueuePendingEvents(q))
+    result = waitForEventsOnDarwin(q, aTimeout);
+  if (result == 0)
+    q->ProcessPendingEvents();
+
+# else  /* !RT_OS_DARWIN */
+
   PRBool hasEvents = PR_FALSE;
   nsresult rc;
-  PRInt32 fd, result = 0;
-
-  if (q == nsnull) 
-    return NULL;
+  PRInt32 fd;
 
   if (aTimeout == 0)
@@ -521 +644 @@
   if (hasEvents)
     goto ok;
-  
+
   fd = q->GetEventQueueSelectFD();
   if (fd < 0 && aTimeout < 0)
@@ -537 +660 @@
   /* Cannot perform timed wait otherwise */
   if (fd < 0)
-#ifdef RT_OS_DARWIN
-      /** 
-       * @todo: maybe need some way to implement timed wait on Darwin,
-       *        just return immediately instead
-       */
-      goto ok;
-#else
       return NULL;
-#endif
-  
+
   {
     fd_set fdsetR, fdsetE;
     struct timeval tv;
-    
+
     FD_ZERO(&fdsetR);
     FD_SET(fd, &fdsetR);
@@ -560 +675 @@
         tv.tv_usec = ((PRInt64)aTimeout % 1000) * 1000;
       }
-    
+
     /** @todo: What to do for XPCOM platforms w/o select() ? */
     Py_BEGIN_ALLOW_THREADS;
@@ -569 +684 @@
  ok:
   q->ProcessPendingEvents();
+# endif /* !RT_OS_DARWIN */
 
   return PyInt_FromLong(result);
@@ -583 +699 @@
 }
 
-static PyObject* 
+static PyObject*
 PyXPCOMMethod_InterruptWait(PyObject *self, PyObject *args)
 {
@@ -610 +726 @@
 static void deinitVBoxPython();
 
-static PyObject* 
+static PyObject*
 PyXPCOMMethod_DeinitCOM(PyObject *self, PyObject *args)
 {
@@ -621 +737 @@
 static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
 
-static PyObject* 
+static PyObject*
 PyXPCOMMethod_AttachThread(PyObject *self, PyObject *args)
 {
@@ -653 +769 @@
 }
 
-static PyObject* 
+static PyObject*
 PyXPCOMMethod_DetachThread(PyObject *self, PyObject *args)
 {
@@ -684 +800 @@
     return PyInt_FromLong(result);
 }
-#endif
+
+#endif /* VBOX */
 
 extern PYXPCOM_EXPORT PyObject *PyXPCOMMethod_IID(PyObject *self, PyObject *args);
@@ -863 +980 @@
 }
 
-static 
+static
 void deinitVBoxPython()
 {
 
   if (g_mainEventQ)
-    NS_RELEASE(g_mainEventQ); 
-  
+    NS_RELEASE(g_mainEventQ);
+
   com::Shutdown();
 }
-#endif
+
+#endif /* VBOX_PYXPCOM */