Changeset 50336 in vbox for trunk

Timestamp:

Feb 5, 2014 7:10:45 PM (11 years ago)

Author:

vboxsync

Message:

Additions/x11/VBoxClient: removed more unnecessary abstraction.

Location:

trunk/src/VBox/Additions/x11/VBoxClient

Files:

• Makefile.kmk (modified) (2 diffs)
• seamless-host.cpp (modified) (8 diffs)
• seamless-host.h (modified) (6 diffs)
• seamless-x11.h (modified) (1 diff)
• seamless.h (modified) (5 diffs)
• thread.cpp (deleted)
• thread.h (deleted)

trunk/src/VBox/Additions/x11/VBoxClient/Makefile.kmk

@@ -62 +62 @@
         seamless-host.cpp \
         seamless-x11.cpp \
-        thread.cpp \
         display.cpp \
         hostversion.cpp
@@ -112 +111 @@
            testcase/tstSeamlessX11.cpp \
            seamless-host.cpp \
-           seamless-x11.cpp \
-           thread.cpp
+           seamless-x11.cpp
    tstSeamlessX11_LIBPATH = \
            $(VBOX_LIBPATH_X11)

trunk/src/VBox/Additions/x11/VBoxClient/seamless-host.cpp

@@ -25 +25 @@
 
 #include "seamless-host.h"
+#include "seamless-x11.h"
 
 /**
@@ -35 +36 @@
 
     LogRelFlowFunc(("\n"));
-    if (mRunning)  /* Assertion */
+    if (mThread)  /* Assertion */
     {
         LogRel(("VBoxClient: seamless service started twice!\n"));
@@ -49 +50 @@
     {
         LogRel(("VBoxClient: enabled seamless capability on host.\n"));
-        rc = mThread.start();
-        if (RT_SUCCESS(rc))
-        {
-            mRunning = true;
-        }
-        else
+        rc = RTThreadCreate(&mThread, threadFunction, this, 0,
+                            RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
+                            "Host events");
+        if (RT_FAILURE(rc))
         {
             LogRel(("VBoxClient: failed to start seamless event thread, rc=%Rrc.  Disabled seamless capability on host again.\n", rc));
@@ -71 +70 @@
 void VBoxGuestSeamlessHost::stop(RTMSINTERVAL cMillies /* = RT_INDEFINITE_WAIT */)
 {
-    LogRelFlowFunc(("returning\n"));
-    if (!mRunning)  /* Assertion */
-    {
+    LogRelFlowFunc(("\n"));
+    if (!mThread)  /* Assertion */
         LogRel(("VBoxClient: tried to stop seamless service which is not running!\n"));
-        return;
-    }
-    mThread.stop(cMillies, 0);
+    else
+        stopThread(cMillies);
+    if (mX11MonitorRTThread)
+        stopX11Thread();
     VbglR3CtlFilterMask(0, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
     VbglR3SeamlessSetCap(false);
-    mRunning = false;
     LogRelFlowFunc(("returning\n"));
 }
@@ -106 +104 @@
 #endif
                 mState = ENABLE;
-                mX11MonitorThread->start();
+                mX11ThreadStopping = false;
+                /** @todo Do something on failure, like bail out. */
+                if (RT_FAILURE(RTThreadCreate(&mX11MonitorRTThread,
+                               x11ThreadFunction, this, 0, RTTHREADTYPE_MSG_PUMP,
+                               RTTHREADFLAGS_WAITABLE, "X11 events")))
+                    LogRelFunc(("Warning: failed to start X11 monitor thread (VBoxClient).\n"));
                 break;
             case VMMDev_Seamless_Host_Window:
@@ -120 +123 @@
 #endif
                 mState = DISABLE;
-                mX11MonitorThread->stop(RT_INDEFINITE_WAIT, 0);
+                if (mX11MonitorRTThread)
+                    stopX11Thread();
+                else
+                    LogRelThisFunc(("Attempted to stop X11 monitor thread which is not running (VBoxClient)!\n"));
         }
     }
@@ -146 +152 @@
 }
 
-/**
- * The actual thread function.
- *
- * @returns iprt status code as thread return value
- * @param pParent the VBoxGuestThread running this thread function
- */
-int VBoxGuestSeamlessHostThread::threadFunction(VBoxGuestThread *pThread)
-{
-    LogRelFlowFunc(("\n"));
-    if (0 != mHost)
-    {
-        mThread = pThread;
-        while (!mThread->isStopping())
-        {
-            if (RT_FAILURE(mHost->nextEvent()) && !mThread->isStopping())
+
+/**
+ * The actual event thread function.
+ */
+int VBoxGuestSeamlessHost::threadFunction(RTTHREAD self, void *pvUser)
+{
+    VBoxGuestSeamlessHost *pHost = (VBoxGuestSeamlessHost *)pvUser;
+
+    LogRelFlowFunc(("\n"));
+    pHost->mThreadRunning = true;
+    if (0 != pHost)
+    {
+        while (!pHost->mThreadStopping)
+        {
+            if (RT_FAILURE(pHost->nextEvent()) && !pHost->mThreadStopping)
             {
                 /* If we are not stopping, sleep for a bit to avoid using up too
                     much CPU while retrying. */
-                mThread->yield();
+                RTThreadYield();
             }
         }
     }
+    pHost->mThreadRunning = false;
     LogRelFlowFunc(("returning VINF_SUCCESS\n"));
     return VINF_SUCCESS;
@@ -173 +180 @@
 
 /**
+ * Send a signal to the thread that it should exit
+ */
+void VBoxGuestSeamlessHost::stopThread(RTMSINTERVAL cMillies)
+{
+    int rc;
+
+    LogRelFlowFunc(("\n"));
+    /**
+     * @todo is this reasonable?  If the thread is in the event loop then the cancelEvent()
+     *       will cause it to exit.  If it enters or exits the event loop it will also
+     *       notice that we wish it to exit.  And if it is somewhere in-between, the
+     *       yield() should give it time to get to one of places mentioned above.
+     */
+    mThreadStopping = true;
+    for (int i = 0; (i < 5) && mThreadRunning; ++i)
+    {
+        cancelEvent();
+        RTThreadYield();
+    }
+    rc = RTThreadWait(mThread, RT_INDEFINITE_WAIT, NULL);
+    if (RT_SUCCESS(rc))
+        mThread = NIL_RTTHREAD;
+    else
+        LogRelThisFunc(("Failed to stop seamless event thread, rc=%Rrc!\n",
+                        rc));
+    LogRelFlowFunc(("returning\n"));
+}
+
+/**
+ * The actual X11 event thread function.
+ */
+int VBoxGuestSeamlessHost::x11ThreadFunction(RTTHREAD self, void *pvUser)
+{
+    VBoxGuestSeamlessHost *pHost = (VBoxGuestSeamlessHost *)pvUser;
+    int rc = VINF_SUCCESS;
+
+    LogRelFlowFunc(("\n"));
+    rc = pHost->mX11Monitor->start();
+    if (RT_SUCCESS(rc))
+    {
+        while (!pHost->mX11ThreadStopping)
+        {
+            pHost->mX11Monitor->nextEvent();
+        }
+        pHost->mX11Monitor->stop();
+    }
+    LogRelFlowFunc(("returning %Rrc\n", rc));
+    return rc;
+}
+
+/**
  * Send a signal to the thread function that it should exit
  */
-void VBoxGuestSeamlessHostThread::stop(void)
-{
-    LogRelFlowFunc(("\n"));
-    if (0 != mHost)
-    {
-        /**
-         * @todo is this reasonable?  If the thread is in the event loop then the cancelEvent()
-         *       will cause it to exit.  If it enters or exits the event loop it will also
-         *       notice that we wish it to exit.  And if it is somewhere in-between, the
-         *       yield() should give it time to get to one of places mentioned above.
-         */
-        for (int i = 0; (i < 5) && mThread->isRunning(); ++i)
-        {
-            mHost->cancelEvent();
-            mThread->yield();
-        }
-    }
-    LogRelFlowFunc(("returning\n"));
-}
+void VBoxGuestSeamlessHost::stopX11Thread(void)
+{
+    int rc;
+
+    mX11ThreadStopping = true;
+    mX11Monitor->interruptEvent();
+    rc = RTThreadWait(mX11MonitorRTThread, RT_INDEFINITE_WAIT, NULL);
+    if (RT_SUCCESS(rc))
+        mX11MonitorRTThread = NIL_RTTHREAD;
+    else
+        LogRelThisFunc(("Failed to stop X11 monitor thread, rc=%Rrc!\n",
+                        rc));
+}

trunk/src/VBox/Additions/x11/VBoxClient/seamless-host.h

@@ -19 +19 @@
 # define __Additions_client_seamless_host_h
 
+#include <iprt/thread.h>
+
 #include <VBox/log.h>
 #include <VBox/VBoxGuestLib.h>      /* for the R3 guest library functions  */
 
-#include "thread.h"                 /* for VBoxGuestThread */
-
-class VBoxGuestSeamlessHost;
-
-/**
- * Host event (i.e. enter or leave seamless mode) thread function for the main
- * seamless class
- */
-class VBoxGuestSeamlessHostThread : public VBoxGuestThreadFunction
-{
-private:
-    // Copying or assigning a thread object is not sensible
-    VBoxGuestSeamlessHostThread(const VBoxGuestSeamlessHostThread&);
-    VBoxGuestSeamlessHostThread& operator=(const VBoxGuestSeamlessHostThread&);
-
-    // Private member variables
-    /** The host proxy object */
-    VBoxGuestSeamlessHost *mHost;
-
-    /** The thread object running us. */
-    VBoxGuestThread *mThread;
-public:
-    VBoxGuestSeamlessHostThread(VBoxGuestSeamlessHost *pHost)
-    {
-        mHost = pHost;
-    }
-    virtual ~VBoxGuestSeamlessHostThread(void) {}
-    /**
-      * The actual thread function.
-      *
-      * @returns iprt status code as thread return value
-      * @param pParent the VBoxGuestThread running this thread function
-      */
-    virtual int threadFunction(VBoxGuestThread *pThread);
-    /**
-     * Send a signal to the thread function that it should exit
-     */
-    virtual void stop(void);
-};
+class VBoxGuestSeamlessX11;
 
 /**
@@ -78 +42 @@
 class VBoxGuestSeamlessHost : public VBoxGuestSeamlessHostInt
 {
-    friend class VBoxGuestSeamlessHostThread;
 public:
     /** Events which can be reported by this class */
@@ -98 +61 @@
     /** Thread to start and stop when we enter and leave seamless mode which
      *  monitors X11 windows in the guest. */
-    VBoxGuestThread *mX11MonitorThread;
-    /** Host seamless event (i.e. enter and leave) thread function. */
-    VBoxGuestSeamlessHostThread mThreadFunction;
+    RTTHREAD mX11MonitorRTThread;
+    /** X11 event monitor class */
+    VBoxGuestSeamlessX11 *mX11Monitor;
+    /** Should the X11 monitor thread be stopping? */
+    volatile bool mX11ThreadStopping;
     /** Host seamless event thread. */
-    VBoxGuestThread mThread;
-    /** Is the service running? */
-    bool mRunning;
+    RTTHREAD mThread;
+    /** Is the thread running? */
+    volatile bool mThreadRunning;
+    /** Should the thread be stopping? */
+    volatile bool mThreadStopping;
     /** Last request issued by the host. */
     meEvent mState;
@@ -120 +87 @@
      */
     void cancelEvent(void) { VbglR3InterruptEventWaits(); }
+    
+    /** Thread function to query seamless activation and deactivation events
+     *  from the host. */
+    static DECLCALLBACK(int) threadFunction(RTTHREAD self, void *pvUser);
+
+    /** Helper to stop the event query thread again. */
+    void stopThread(RTMSINTERVAL cMillies);
+
+    /** Thread function to monitor X11 window configuration changes. */
+    static DECLCALLBACK(int) x11ThreadFunction(RTTHREAD self, void *pvUser);
+
+    /** Helper to stop the X11 monitor thread again. */
+    void stopX11Thread(void);
 
 public:
     /**
      * Initialise the guest and ensure that it is capable of handling seamless mode
-     * @param   pX11MonitorThread Thread class to monitor guest windows.
+     * @param   pX11Monitor Object to monitor X11 guest windows.
      *
      * @returns iprt status code
      */
-    int init(VBoxGuestThread *pX11MonitorThread)
+    int init(VBoxGuestSeamlessX11 *pX11Monitor)
     {
         LogRelFlowFunc(("\n"));
-        if (mX11MonitorThread != 0)  /* Assertion */
+        if (mX11Monitor != NULL)  /* Assertion */
         {
             LogRel(("VBoxClient: ERROR: attempt to initialise seamless host object twice!\n"));
             return VERR_INTERNAL_ERROR;
         }
-        mX11MonitorThread = pX11MonitorThread;
+        mX11Monitor = pX11Monitor;
         LogRelFlowFunc(("returning VINF_SUCCESS\n"));
         return VINF_SUCCESS;
@@ -161 +141 @@
     virtual void notify(RTRECT *pRects, size_t cRects);
 
-    VBoxGuestSeamlessHost(void) : mThreadFunction(this),
-                                  mThread(&mThreadFunction, 0, RTTHREADTYPE_MSG_PUMP,
-                                  RTTHREADFLAGS_WAITABLE, "Host events")
+    VBoxGuestSeamlessHost(void)
     {
-        mX11MonitorThread = 0;
-        mRunning = false;
+        mX11MonitorRTThread = NIL_RTTHREAD;
+        mX11Monitor = NULL;
+        mX11ThreadStopping = false;
+        mThread = NIL_RTTHREAD;
+        mThreadRunning = false;
+        mThreadStopping = false;
         mState = NONE;
     }
@@ -173 +155 @@
     {
         LogRelFlowFunc(("\n"));
-        if (mRunning)  /* Assertion */
+        if (mThread)  /* Assertion */
         {
             LogRel(("VBoxClient: seamless host object still running!  Stopping...\n"));

trunk/src/VBox/Additions/x11/VBoxClient/seamless-x11.h

@@ -147 +147 @@
 };
 
-class VBoxGuestSeamlessX11;
-
 class VBoxGuestSeamlessX11
 {

trunk/src/VBox/Additions/x11/VBoxClient/seamless.h

@@ -24 +24 @@
 #include "seamless-x11.h"
 
-/** Thread function class for VBoxGuestSeamlessX11. */
-class VBoxGuestSeamlessGuestThread: public VBoxGuestThreadFunction
-{
-private:
-    /** The guest class "owning" us. */
-    VBoxGuestSeamlessX11 *mGuest;
-    /** Should we exit the thread? */
-    bool mExit;
-
-    // Copying or assigning a thread object is not sensible
-    VBoxGuestSeamlessGuestThread(const VBoxGuestSeamlessGuestThread&);
-    VBoxGuestSeamlessGuestThread& operator=(const VBoxGuestSeamlessGuestThread&);
-
-public:
-    VBoxGuestSeamlessGuestThread(VBoxGuestSeamlessX11 *pGuest)
-    { mGuest = pGuest; mExit = false; }
-    virtual ~VBoxGuestSeamlessGuestThread(void) {}
-    /**
-      * The actual thread function.
-      *
-      * @returns iprt status code as thread return value
-      * @param pParent the VBoxGuestThread running this thread function
-      */
-    virtual int threadFunction(VBoxGuestThread *pThread)
-    {
-        int rc = VINF_SUCCESS;
-
-        LogRelFlowFunc(("\n"));
-        rc = mGuest->start();
-        if (RT_SUCCESS(rc))
-        {
-            while (!pThread->isStopping())
-            {
-                mGuest->nextEvent();
-            }
-            mGuest->stop();
-        }
-        LogRelFlowFunc(("returning %Rrc\n", rc));
-        return rc;
-    }
-    /**
-     * Send a signal to the thread function that it should exit
-     */
-    virtual void stop(void) { mGuest->interruptEvent(); }
-};
-
 class VBoxGuestSeamless
 {
@@ -75 +29 @@
     VBoxGuestSeamlessHost mHost;
     VBoxGuestSeamlessX11 mGuest;
-    VBoxGuestSeamlessGuestThread mGuestFunction;
-    VBoxGuestThread mGuestThread;
 
     bool isInitialised;
@@ -92 +44 @@
         if (RT_SUCCESS(rc))
         {
-            rc = mHost.init(&mGuestThread);
+            rc = mHost.init(&mGuest);
         }
         if (RT_SUCCESS(rc))
@@ -120 +72 @@
         {
             mHost.stop(cMillies);
-            mGuestThread.stop(cMillies, 0);
             mGuest.uninit();
             isInitialised = false;
@@ -127 +78 @@
     }
 
-    VBoxGuestSeamless() : mGuestFunction(&mGuest),
-                          mGuestThread(&mGuestFunction, 0, RTTHREADTYPE_MSG_PUMP,
-                                       RTTHREADFLAGS_WAITABLE, "Guest events")
-    {
-        isInitialised = false;
-    }
+    VBoxGuestSeamless() { isInitialised = false; }
     ~VBoxGuestSeamless() { uninit(); }
 };