1 files changed, 290 insertions, 9 deletions

diff --git a/tests/auto/qglthreads/tst_qglthreads.cpp b/tests/auto/qglthreads/tst_qglthreads.cpp
index 06131bd..9441406 100644
--- a/tests/auto/qglthreads/tst_qglthreads.cpp
+++ b/tests/auto/qglthreads/tst_qglthreads.cpp
@@ -45,10 +45,6 @@
 #include <QtOpenGL/QtOpenGL>
 #include "tst_qglthreads.h"
 
-#ifdef Q_WS_X11
-#include <private/qt_x11_p.h>
-#endif
-
 #ifdef Q_OS_SYMBIAN
 #include <unistd.h> // for usleep
 #endif
@@ -60,8 +56,6 @@ tst_QGLThreads::tst_QGLThreads(QObject *parent)
 {
 }
 
-
-
 /*
 
    swapInThread
@@ -344,6 +338,7 @@ void renderAScene(int w, int h)
 class ThreadSafeGLWidget : public QGLWidget
 {
 public:
+    ThreadSafeGLWidget(QWidget *parent = 0) : QGLWidget(parent) {}
     void paintEvent(QPaintEvent *)
     {
         // ignored as we're anyway swapping as fast as we can
@@ -431,7 +426,7 @@ void tst_QGLThreads::renderInThread_data()
 void tst_QGLThreads::renderInThread()
 {
 #ifdef Q_OS_MAC
-    QSKIP("OpenGL threading tests are currently disabled on mac as they were causing reboots", SkipAll);
+    QSKIP("OpenGL threading tests are currently disabled on Mac as they were causing reboots", SkipAll);
 #endif
 
     QFETCH(bool, resize);
@@ -466,15 +461,301 @@ void tst_QGLThreads::renderInThread()
     QVERIFY(!thread.failure);
 }
 
+class Device
+{
+public:
+    virtual ~Device() {}
+    virtual QPaintDevice *realPaintDevice() = 0;
+    virtual void prepareDevice() {}
+};
+
+class GLWidgetWrapper : public Device
+{
+public:
+    GLWidgetWrapper() {
+        widget.resize(150, 150);
+        widget.show();
+        QTest::qWaitForWindowShown(&widget);
+        widget.doneCurrent();
+    }
+    QPaintDevice *realPaintDevice() { return &widget; }
 
+    ThreadSafeGLWidget widget;
+};
 
+class PixmapWrapper : public Device
+{
+public:
+    PixmapWrapper() { pixmap = new QPixmap(512, 512); }
+    ~PixmapWrapper() { delete pixmap; }
+    QPaintDevice *realPaintDevice() { return pixmap; }
 
-int main(int argc, char **argv)
+    QPixmap *pixmap;
+};
+
+class PixelBufferWrapper : public Device
+{
+public:
+    PixelBufferWrapper() { pbuffer = new QGLPixelBuffer(512, 512); }
+    ~PixelBufferWrapper() { delete pbuffer; }
+    QPaintDevice *realPaintDevice() { return pbuffer; }
+
+    QGLPixelBuffer *pbuffer;
+};
+
+
+class FrameBufferObjectWrapper : public Device
+{
+public:
+    FrameBufferObjectWrapper() {
+        widget.makeCurrent();
+        fbo = new QGLFramebufferObject(512, 512);
+        widget.doneCurrent();
+    }
+    ~FrameBufferObjectWrapper() { delete fbo; }
+    QPaintDevice *realPaintDevice() { return fbo; }
+    void prepareDevice() { widget.makeCurrent(); }
+
+    ThreadSafeGLWidget widget;
+    QGLFramebufferObject *fbo;
+};
+
+
+class ThreadPainter : public QObject
+{
+    Q_OBJECT
+public:
+    ThreadPainter(Device *pd) : device(pd), fail(true) {
+        pixmap = QPixmap(40, 40);
+        pixmap.fill(Qt::green);
+        QPainter p(&pixmap);
+        p.drawLine(0, 0, 40, 40);
+        p.drawLine(0, 40, 40, 0);
+    }
+
+public slots:
+    void draw() {
+        bool beginFailed = false;
+        QTime time;
+        time.start();
+        int rotAngle = 10;
+        device->prepareDevice();
+        QPaintDevice *paintDevice = device->realPaintDevice();
+        QSize s(paintDevice->width(), paintDevice->height());
+        while (time.elapsed() < RUNNING_TIME) {
+            QPainter p;
+            if (!p.begin(paintDevice)) {
+                beginFailed = true;
+                break;
+            }
+            p.translate(s.width()/2, s.height()/2);
+            p.rotate(rotAngle);
+            p.translate(-s.width()/2, -s.height()/2);
+            p.fillRect(0, 0, s.width(), s.height(), Qt::red);
+            QRect rect(QPoint(0, 0), s);
+            p.drawPixmap(10, 10, pixmap);
+            p.drawTiledPixmap(50, 50, 100, 100, pixmap);
+            p.drawText(rect.center(), "This is a piece of text");
+            p.end();
+            rotAngle += 2;
+#ifdef Q_WS_WIN
+            Sleep(20);
+#else
+            usleep(20 * 1000);
+#endif
+        }
+
+        fail = beginFailed;
+        QThread::currentThread()->quit();
+    }
+
+    bool failed() { return fail; }
+
+private:
+    QPixmap pixmap;
+    Device *device;
+    bool fail;
+};
+
+template <class T>
+class PaintThreadManager
+{
+public:
+    PaintThreadManager(int count) : numThreads(count)
+    {
+        for (int i=0; i<numThreads; ++i) {
+            devices.append(new T);
+            threads.append(new QThread);
+            painters.append(new ThreadPainter(devices.at(i)));
+            painters.at(i)->moveToThread(threads.at(i));
+            painters.at(i)->connect(threads.at(i), SIGNAL(started()), painters.at(i), SLOT(draw()));
+        }
+    }
+
+    ~PaintThreadManager() {
+        qDeleteAll(threads);
+        qDeleteAll(painters);
+        qDeleteAll(devices);
+    }
+
+
+    void start() {
+        for (int i=0; i<numThreads; ++i)
+            threads.at(i)->start();
+    }
+
+    bool areRunning() {
+        bool running = false;
+        for (int i=0; i<numThreads; ++i){
+            if (threads.at(i)->isRunning())
+                running = true;
+        }
+
+        return running;
+    }
+
+    bool failed() {
+        for (int i=0; i<numThreads; ++i) {
+            if (painters.at(i)->failed())
+                return true;
+        }
+
+        return false;
+    }
+
+private:
+    QList<QThread *> threads;
+    QList<Device *> devices;
+    QList<ThreadPainter *> painters;
+    int numThreads;
+};
+
+/*
+   This test uses QPainter to draw onto different QGLWidgets in
+   different threads at the same time. The ThreadSafeGLWidget is
+   necessary to handle paint and resize events that might come from
+   the main thread at any time while the test is running. The resize
+   and paint events would cause makeCurrent() calls to be issued from
+   within the QGLWidget while the widget's context was current in
+   another thread, which would cause errors.
+*/
+void tst_QGLThreads::painterOnGLWidgetInThread()
+{
+#ifdef Q_OS_MAC
+    QSKIP("OpenGL threading tests are currently disabled on Mac as they were causing reboots", SkipAll);
+#endif
+    if (!((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0) ||
+          (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0))) {
+        QSKIP("The OpenGL based threaded QPainter tests requires OpenGL/ES 2.0.", SkipAll);
+    }
+
+    PaintThreadManager<GLWidgetWrapper> painterThreads(5);
+    painterThreads.start();
+
+    while (painterThreads.areRunning()) {
+        qApp->processEvents();
+#ifdef Q_WS_WIN
+        Sleep(100);
+#else
+        usleep(100 * 1000);
+#endif
+    }
+    QVERIFY(!painterThreads.failed());
+}
+
+/*
+   This test uses QPainter to draw onto different QPixmaps in
+   different threads at the same time.
+*/
+void tst_QGLThreads::painterOnPixmapInThread()
 {
 #ifdef Q_WS_X11
-    XInitThreads();
+    QSKIP("Drawing text in threads onto X11 drawables currently crashes on some X11 servers.", SkipAll);
+#endif
+    PaintThreadManager<PixmapWrapper> painterThreads(5);
+    painterThreads.start();
+
+    while (painterThreads.areRunning()) {
+        qApp->processEvents();
+#ifdef Q_WS_WIN
+        Sleep(100);
+#else
+        usleep(100 * 1000);
+#endif
+    }
+    QVERIFY(!painterThreads.failed());
+}
+
+/* This test uses QPainter to draw onto different QGLPixelBuffer
+   objects in different threads at the same time.
+*/
+void tst_QGLThreads::painterOnPboInThread()
+{
+#ifdef Q_OS_MAC
+    QSKIP("OpenGL threading tests are currently disabled on Mac as they were causing reboots", SkipAll);
+#endif
+    if (!((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0) ||
+          (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0))) {
+        QSKIP("The OpenGL based threaded QPainter tests requires OpenGL/ES 2.0.", SkipAll);
+        return;
+    }
+
+    if (!QGLPixelBuffer::hasOpenGLPbuffers()) {
+        QSKIP("This system doesn't support pbuffers.", SkipAll);
+        return;
+    }
+
+    PaintThreadManager<PixelBufferWrapper> painterThreads(5);
+    painterThreads.start();
+
+    while (painterThreads.areRunning()) {
+        qApp->processEvents();
+#ifdef Q_WS_WIN
+        Sleep(100);
+#else
+        usleep(100 * 1000);
 #endif
+    }
+    QVERIFY(!painterThreads.failed());
+}
 
+/* This test uses QPainter to draw onto different
+   QGLFramebufferObjects (bound in a QGLWidget's context) in different
+   threads at the same time.
+*/
+void tst_QGLThreads::painterOnFboInThread()
+{
+#ifdef Q_OS_MAC
+    QSKIP("OpenGL threading tests are currently disabled on Mac as they were causing reboots", SkipAll);
+#endif
+    if (!((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0) ||
+          (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0))) {
+        QSKIP("The OpenGL based threaded QPainter tests requires OpenGL/ES 2.0.", SkipAll);
+        return;
+    }
+
+    if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()) {
+        QSKIP("This system doesn't support framebuffer objects.", SkipAll);
+        return;
+    }
+
+    PaintThreadManager<FrameBufferObjectWrapper> painterThreads(5);
+    painterThreads.start();
+
+    while (painterThreads.areRunning()) {
+        qApp->processEvents();
+#ifdef Q_WS_WIN
+        Sleep(100);
+#else
+        usleep(100 * 1000);
+#endif
+    }
+    QVERIFY(!painterThreads.failed());
+}
+
+int main(int argc, char **argv)
+{
+    QApplication::setAttribute(Qt::AA_X11InitThreads);
     QApplication app(argc, argv);
     QTEST_DISABLE_KEYPAD_NAVIGATION \