Remove QtWayland::Compositor and add QWaylandCompositorPrivate

Embrace PIMPL

Change-Id: I8c8b5971e15c208317ff33231bda1513e7b8d489

60 files changed, 713 insertions, 1093 deletions

diff --git a/examples/wayland/server-buffer/compositor/main.cpp b/examples/wayland/server-buffer/compositor/main.cpp
index edae5b063..1984cb0cd 100644
--- a/examples/wayland/server-buffer/compositor/main.cpp
+++ b/examples/wayland/server-buffer/compositor/main.cpp
@@ -57,7 +57,8 @@
 
 #include "qwayland-server-share-buffer.h"
 #include <QtCompositor/qwaylandoutput.h>
-#include <QtCompositor/private/qwlcompositor_p.h>
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/private/qwaylandcompositor_p.h>
 #include <QtCompositor/private/qwlserverbufferintegration_p.h>
 
 #include "serverbufferitem.h"
@@ -73,7 +74,7 @@ class QmlCompositor
 public:
     QmlCompositor()
         : QWaylandQuickCompositor()
-        , QtWaylandServer::qt_share_buffer(QWaylandCompositor::handle()->wl_display(), 1)
+        , QtWaylandServer::qt_share_buffer(QWaylandCompositor::display(), 1)
         , m_server_buffer_32_bit(0)
         , m_server_buffer_item_32_bit(0)
         , m_server_buffer_8_bit(0)
@@ -138,12 +139,12 @@ private slots:
 
     void initiateServerBuffer()
     {
-        if (!QWaylandCompositor::handle()->serverBufferIntegration())
+        if (!QWaylandCompositorPrivate::get(this)->serverBufferIntegration())
             return;
 
         m_view.openglContext()->makeCurrent(&m_view);
 
-        QtWayland::ServerBufferIntegration *sbi = QWaylandCompositor::handle()->serverBufferIntegration();
+        QtWayland::ServerBufferIntegration *sbi = QWaylandCompositorPrivate::get(this)->serverBufferIntegration();
         if (!sbi) {
             qWarning("Could not find a Server Buffer Integration");
             return;
diff --git a/src/compositor/compositor_api/compositor_api.pri b/src/compositor/compositor_api/compositor_api.pri
index c97e16e27..5d2a24f0f 100644
--- a/src/compositor/compositor_api/compositor_api.pri
+++ b/src/compositor/compositor_api/compositor_api.pri
@@ -2,6 +2,7 @@ INCLUDEPATH += compositor_api
 
 HEADERS += \
     compositor_api/qwaylandcompositor.h \
+    compositor_api/qwaylandcompositor_p.h \
     compositor_api/qwaylandclient.h \
     compositor_api/qwaylandsurface.h \
     compositor_api/qwaylandsurface_p.h \
diff --git a/src/compositor/compositor_api/qwaylandclient.cpp b/src/compositor/compositor_api/qwaylandclient.cpp
index 1b3db5858..df5cf7d27 100644
--- a/src/compositor/compositor_api/qwaylandclient.cpp
+++ b/src/compositor/compositor_api/qwaylandclient.cpp
@@ -34,11 +34,12 @@
 **
 ****************************************************************************/
 
-#include <private/qobject_p.h>
-
-#include "wayland_wrapper/qwlcompositor_p.h"
-#include "qwaylandcompositor.h"
 #include "qwaylandclient.h"
+#include <QtCore/private/qobject_p.h>
+
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/private/qwaylandcompositor_p.h>
+
 
 #include <wayland-server.h>
 #include <wayland-util.h>
@@ -93,7 +94,7 @@ QWaylandClient::QWaylandClient(QWaylandCompositor *compositor, wl_client *client
     d->listener.listener.notify = QWaylandClientPrivate::client_destroy_callback;
     wl_client_add_destroy_listener(client, &d->listener.listener);
 
-    compositor->handle()->m_clients.append(this);
+    QWaylandCompositorPrivate::get(compositor)->addClient(this);
 }
 
 QWaylandClient::~QWaylandClient()
@@ -103,7 +104,7 @@ QWaylandClient::~QWaylandClient()
     // Remove listener from signal
     wl_list_remove(&d->listener.listener.link);
 
-    d->compositor->handle()->m_clients.removeOne(this);
+    QWaylandCompositorPrivate::get(d->compositor)->removeClient(this);
 }
 
 QWaylandClient *QWaylandClient::fromWlClient(QWaylandCompositor *compositor, wl_client *wlClient)
diff --git a/src/compositor/compositor_api/qwaylandcompositor.cpp b/src/compositor/compositor_api/qwaylandcompositor.cpp
index d86b48d8a..2fac37d0d 100644
--- a/src/compositor/compositor_api/qwaylandcompositor.cpp
+++ b/src/compositor/compositor_api/qwaylandcompositor.cpp
@@ -36,97 +36,378 @@
 ****************************************************************************/
 
 #include "qwaylandcompositor.h"
-
-#include "qwaylandclient.h"
-#include "qwaylandinput.h"
-#include "qwaylandoutput.h"
-#include "qwaylandview.h"
-#include "qwaylandclient.h"
-#include "qwaylandkeyboard.h"
-#include "qwaylandpointer.h"
-#include "qwaylandtouch.h"
+#include "qwaylandcompositor_p.h"
+
+#include <QtCompositor/qwaylandclient.h>
+#include <QtCompositor/qwaylandinput.h>
+#include <QtCompositor/qwaylandoutput.h>
+#include <QtCompositor/qwaylandview.h>
+#include <QtCompositor/qwaylandclient.h>
+#include <QtCompositor/qwaylandkeyboard.h>
+#include <QtCompositor/private/qwlkeyboard_p.h>
+#include <QtCompositor/qwaylandpointer.h>
+#include <QtCompositor/qwaylandtouch.h>
 
 #include "qwaylandsurface_p.h"
 
-#include "wayland_wrapper/qwlcompositor_p.h"
 #include "wayland_wrapper/qwldatadevice_p.h"
 #include "wayland_wrapper/qwlinputdevice_p.h"
+#include "wayland_wrapper/qwldatadevicemanager_p.h"
 
 #include "extensions/qwlinputpanel_p.h"
 #include "extensions/qwlshellsurface_p.h"
+#include "extensions/qwlextendedsurface_p.h"
+#include "extensions/qwlsubsurface_p.h"
+#include "extensions/qwlqttouch_p.h"
+#include "extensions/qwlqtkey_p.h"
+#include "extensions/qwltextinputmanager_p.h"
+#include "extensions/qwaylandwindowmanagerextension.h"
+
+#include "hardware_integration/qwlhwintegration_p.h"
+#include "hardware_integration/qwlclientbufferintegration_p.h"
+#include "hardware_integration/qwlclientbufferintegrationfactory_p.h"
+#include "hardware_integration/qwlserverbufferintegration_p.h"
+#include "hardware_integration/qwlserverbufferintegrationfactory_p.h"
+
+
+#include "qwaylandxkb.h"
+#include "qwaylandshmformathelper.h"
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QStringList>
+#include <QtCore/QSocketNotifier>
 
 #include <QtGui/QDesktopServices>
 #include <QtGui/QScreen>
 
-#include <QDebug>
+#include <QtGui/qpa/qwindowsysteminterface_p.h>
+#include <QtGui/private/qguiapplication_p.h>
 
 QT_BEGIN_NAMESPACE
 
+namespace QtWayland {
+
+class WindowSystemEventHandler : public QWindowSystemEventHandler
+{
+public:
+    WindowSystemEventHandler(QWaylandCompositor *c) : compositor(c) {}
+    bool sendEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *e) Q_DECL_OVERRIDE
+    {
+        if (e->type == QWindowSystemInterfacePrivate::Key) {
+            QWindowSystemInterfacePrivate::KeyEvent *ke = static_cast<QWindowSystemInterfacePrivate::KeyEvent *>(e);
+            QWaylandKeyboardPrivate *keyb = QWaylandKeyboardPrivate::get(compositor->defaultInputDevice()->keyboard());
+
+            uint32_t code = ke->nativeScanCode;
+            bool isDown = ke->keyType == QEvent::KeyPress;
+
+#ifndef QT_NO_WAYLAND_XKB
+            QString text;
+            Qt::KeyboardModifiers modifiers = QWaylandXkb::modifiers(keyb->xkbState());
+
+            const xkb_keysym_t sym = xkb_state_key_get_one_sym(keyb->xkbState(), code);
+            uint utf32 = xkb_keysym_to_utf32(sym);
+            if (utf32)
+                text = QString::fromUcs4(&utf32, 1);
+            int qtkey = QWaylandXkb::keysymToQtKey(sym, modifiers, text);
+
+            ke->key = qtkey;
+            ke->modifiers = modifiers;
+            ke->nativeVirtualKey = sym;
+            ke->nativeModifiers = keyb->xkbModsMask();
+            ke->unicode = text;
+#endif
+            if (!ke->repeat)
+                keyb->keyEvent(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
+
+            QWindowSystemEventHandler::sendEvent(e);
+
+            if (!ke->repeat) {
+                keyb->updateKeymap();
+                keyb->updateModifierState(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
+            }
+        } else {
+            QWindowSystemEventHandler::sendEvent(e);
+        }
+        return true;
+    }
+
+    QWaylandCompositor *compositor;
+};
+
+} // namespace
+
+QWaylandCompositorPrivate::QWaylandCompositorPrivate(QWaylandCompositor *compositor)
+    : extensions(QWaylandCompositor::DefaultExtensions)
+    , display(wl_display_create())
+#if defined (QT_COMPOSITOR_WAYLAND_GL)
+    , hw_integration(0)
+    , client_buffer_integration(0)
+    , server_buffer_integration(0)
+#endif
+    , eventHandler(new QtWayland::WindowSystemEventHandler(compositor))
+    , retainSelection(false)
+    , initialized(false)
+{
+    timer.start();
+
+    QWindowSystemInterfacePrivate::installWindowSystemEventHandler(eventHandler.data());
+}
+
+void QWaylandCompositorPrivate::init()
+{
+    Q_Q(QWaylandCompositor);
+    outputSpaces.append(new QWaylandOutputSpace(q));
+    QStringList arguments = QCoreApplication::instance()->arguments();
+
+    int socketArg = arguments.indexOf(QLatin1String("--wayland-socket-name"));
+    if (socketArg != -1 && socketArg + 1 < arguments.size())
+        socket_name = arguments.at(socketArg + 1).toLocal8Bit();
+
+    wl_compositor::init(display, 3);
+
+    data_device_manager =  new QtWayland::DataDeviceManager(q);
+
+    wl_display_init_shm(display);
+    QVector<wl_shm_format> formats = QWaylandShmFormatHelper::supportedWaylandFormats();
+    foreach (wl_shm_format format, formats)
+        wl_display_add_shm_format(display, format);
+
+    const char *socketName = 0;
+    if (socket_name.size())
+        socketName = socket_name.constData();
+    if (wl_display_add_socket(display, socketName)) {
+        qFatal("Fatal: Failed to open server socket\n");
+    }
+
+    loop = wl_display_get_event_loop(display);
+
+    int fd = wl_event_loop_get_fd(loop);
+
+    QSocketNotifier *sockNot = new QSocketNotifier(fd, QSocketNotifier::Read, q);
+    QObject::connect(sockNot, SIGNAL(activated(int)), q, SLOT(processWaylandEvents()));
+
+    QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher;
+    QObject::connect(dispatcher, SIGNAL(aboutToBlock()), q, SLOT(processWaylandEvents()));
+
+    qRegisterMetaType<QtWayland::SurfaceBuffer*>("SurfaceBuffer*");
+    qRegisterMetaType<QWaylandClient*>("WaylandClient*");
+    qRegisterMetaType<QWaylandSurface*>("WaylandSurface*");
+    qRegisterMetaType<QWaylandView*>("WaylandSurfaceView*");
+    //initialize distancefieldglyphcache here
+
+    initializeHardwareIntegration();
+    initializeExtensions();
+    initializeDefaultInputDevice();
+
+    initialized = true;
+}
+
+QWaylandCompositorPrivate::~QWaylandCompositorPrivate()
+{
+    if (!destroyed_surfaces.isEmpty())
+        qWarning("QWaylandCompositor::cleanupGraphicsResources() must be called manually");
+    qDeleteAll(clients);
+
+    qDeleteAll(outputSpaces);
+
+    delete data_device_manager;
+
+    wl_display_destroy(display);
+}
+
+void QWaylandCompositorPrivate::destroySurface(QWaylandSurface *surface)
+{
+    Q_Q(QWaylandCompositor);
+    q->surfaceAboutToBeDestroyed(surface);
+
+    destroyed_surfaces << surface;
+}
+
+void QWaylandCompositorPrivate::unregisterSurface(QWaylandSurface *surface)
+{
+    if (!all_surfaces.removeOne(surface))
+        qWarning("%s Unexpected state. Cant find registered surface\n", Q_FUNC_INFO);
+}
+
+void QWaylandCompositorPrivate::feedRetainedSelectionData(QMimeData *data)
+{
+    Q_Q(QWaylandCompositor);
+    if (retainSelection)
+        q->retainedSelectionReceived(data);
+}
+
+void QWaylandCompositorPrivate::compositor_create_surface(Resource *resource, uint32_t id)
+{
+    Q_Q(QWaylandCompositor);
+    QWaylandClient *client = QWaylandClient::fromWlClient(q, resource->client());
+    QWaylandSurface *surface = q->createSurface(client, id, resource->version());
+    all_surfaces.append(surface);
+    emit q->surfaceCreated(surface);
+}
+
+void QWaylandCompositorPrivate::compositor_create_region(Resource *resource, uint32_t id)
+{
+    new QtWayland::Region(resource->client(), id);
+}
+
+
+void QWaylandCompositorPrivate::initializeHardwareIntegration()
+{
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    Q_Q(QWaylandCompositor);
+    if (extensions & QWaylandCompositor::HardwareIntegrationExtension)
+        hw_integration.reset(new QtWayland::HardwareIntegration(q));
+
+    loadClientBufferIntegration();
+    loadServerBufferIntegration();
+
+    if (client_buffer_integration)
+        client_buffer_integration->initializeHardware(display);
+    if (server_buffer_integration)
+        server_buffer_integration->initializeHardware(q);
+#endif
+}
+
+void QWaylandCompositorPrivate::initializeExtensions()
+{
+    Q_Q(QWaylandCompositor);
+    if (extensions & QWaylandCompositor::SurfaceExtension)
+        new QtWayland::SurfaceExtensionGlobal(q);
+    if (extensions & QWaylandCompositor::SubSurfaceExtension)
+        new QtWayland::SubSurfaceExtensionGlobal(q);
+    if (extensions & QWaylandCompositor::TouchExtension)
+        new QtWayland::TouchExtensionGlobal(q);
+    if (extensions & QWaylandCompositor::QtKeyExtension)
+        new QtWayland::QtKeyExtensionGlobal(q);
+    if (extensions & QWaylandCompositor::TextInputExtension) {
+        new QtWayland::TextInputManager(q);
+        new QWaylandInputPanel(q);
+    }
+    if (extensions & QWaylandCompositor::WindowManagerExtension)
+        new QWaylandWindowManagerExtension(q);
+}
+
+void QWaylandCompositorPrivate::initializeDefaultInputDevice()
+{
+    Q_Q(QWaylandCompositor);
+    inputDevices.append(q->createInputDevice());
+}
+
+void QWaylandCompositorPrivate::loadClientBufferIntegration()
+{
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    Q_Q(QWaylandCompositor);
+    QStringList keys = QtWayland::ClientBufferIntegrationFactory::keys();
+    QString targetKey;
+    QByteArray clientBufferIntegration = qgetenv("QT_WAYLAND_HARDWARE_INTEGRATION");
+    if (clientBufferIntegration.isEmpty())
+        clientBufferIntegration = qgetenv("QT_WAYLAND_CLIENT_BUFFER_INTEGRATION");
+    if (keys.contains(QString::fromLocal8Bit(clientBufferIntegration.constData()))) {
+        targetKey = QString::fromLocal8Bit(clientBufferIntegration.constData());
+    } else if (keys.contains(QString::fromLatin1("wayland-egl"))) {
+        targetKey = QString::fromLatin1("wayland-egl");
+    } else if (!keys.isEmpty()) {
+        targetKey = keys.first();
+    }
+
+    if (!targetKey.isEmpty()) {
+        client_buffer_integration.reset(QtWayland::ClientBufferIntegrationFactory::create(targetKey, QStringList()));
+        if (client_buffer_integration) {
+            client_buffer_integration->setCompositor(q);
+            if (hw_integration)
+                hw_integration->setClientBufferIntegration(targetKey);
+        }
+    }
+    //BUG: if there is no client buffer integration, bad things will happen when opengl is used
+#endif
+}
+
+void QWaylandCompositorPrivate::loadServerBufferIntegration()
+{
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    QStringList keys = QtWayland::ServerBufferIntegrationFactory::keys();
+    QString targetKey;
+    QByteArray serverBufferIntegration = qgetenv("QT_WAYLAND_SERVER_BUFFER_INTEGRATION");
+    if (keys.contains(QString::fromLocal8Bit(serverBufferIntegration.constData()))) {
+        targetKey = QString::fromLocal8Bit(serverBufferIntegration.constData());
+    }
+    if (!targetKey.isEmpty()) {
+        server_buffer_integration.reset(QtWayland::ServerBufferIntegrationFactory::create(targetKey, QStringList()));
+        if (hw_integration)
+            hw_integration->setServerBufferIntegration(targetKey);
+    }
+#endif
+}
+
 QWaylandCompositor::QWaylandCompositor(QObject *parent)
-    : QObject(parent)
-    , m_compositor(new QtWayland::Compositor(this))
+    : QObject(*new QWaylandCompositorPrivate(this), parent)
 {
 }
 
 QWaylandCompositor::~QWaylandCompositor()
 {
-    delete m_compositor;
 }
 
 void QWaylandCompositor::create()
 {
-    m_compositor->init();
+    Q_D(QWaylandCompositor);
+    d->init();
 }
 
 bool QWaylandCompositor::isCreated() const
 {
-    return m_compositor->m_initialized;
+    Q_D(const QWaylandCompositor);
+    return d->initialized;
 }
 
 void QWaylandCompositor::setSocketName(const QByteArray &name)
 {
-    if (m_compositor->m_initialized) {
+    Q_D(QWaylandCompositor);
+    if (d->initialized) {
         qWarning("%s: It is not supported to alter the compostors socket name after the compositor is initialized\n", Q_FUNC_INFO);
         return;
     }
-    m_compositor->m_socket_name = name;
+    d->socket_name = name;
 }
 
 QByteArray QWaylandCompositor::socketName() const
 {
-    return m_compositor->m_socket_name;
+    Q_D(const QWaylandCompositor);
+    return d->socket_name;
 }
 
 void QWaylandCompositor::setExtensionFlags(QWaylandCompositor::ExtensionFlags flags)
 {
-    if (m_compositor->m_initialized) {
+    Q_D(QWaylandCompositor);
+    if (d->initialized) {
         qWarning("%s: It is not supported to alter the extension flags after the compositor is initialized\n", Q_FUNC_INFO);
         return;
     }
-    m_compositor->m_extensions = flags;
+    d->extensions = flags;
 }
 
 QWaylandCompositor::ExtensionFlags QWaylandCompositor::extensionFlags() const
 {
-    return m_compositor->extensions();
+    Q_D(const QWaylandCompositor);
+    return d->extensions;
 }
 
-struct wl_display *QWaylandCompositor::waylandDisplay() const
+struct wl_display *QWaylandCompositor::display() const
 {
-    return m_compositor->wl_display();
+    Q_D(const QWaylandCompositor);
+    return d->display;
 }
 
 uint32_t QWaylandCompositor::nextSerial()
 {
-    return wl_display_next_serial(waylandDisplay());
+    Q_D(QWaylandCompositor);
+    return wl_display_next_serial(d->display);
 }
 
 QList<QWaylandClient *>QWaylandCompositor::clients() const
 {
-    return m_compositor->clients();
+    Q_D(const QWaylandCompositor);
+    return d->clients;
 }
 
 void QWaylandCompositor::destroyClientForSurface(QWaylandSurface *surface)
@@ -136,13 +417,21 @@ void QWaylandCompositor::destroyClientForSurface(QWaylandSurface *surface)
 
 void QWaylandCompositor::destroyClient(QWaylandClient *client)
 {
-    m_compositor->destroyClient(client);
+    if (!client)
+        return;
+
+    QWaylandWindowManagerExtension *wmExtension = QWaylandWindowManagerExtension::findIn(this);
+    if (wmExtension)
+        wmExtension->sendQuitMessage(client->client());
+
+    wl_client_destroy(client->client());
 }
 
 QList<QWaylandSurface *> QWaylandCompositor::surfacesForClient(QWaylandClient* client) const
 {
+    Q_D(const QWaylandCompositor);
     QList<QWaylandSurface *> surfs;
-    foreach (QWaylandSurface *surface, m_compositor->m_all_surfaces) {
+    foreach (QWaylandSurface *surface, d->all_surfaces) {
         if (surface->client() == client)
             surfs.append(surface);
     }
@@ -151,42 +440,66 @@ QList<QWaylandSurface *> QWaylandCompositor::surfacesForClient(QWaylandClient* c
 
 QList<QWaylandSurface *> QWaylandCompositor::surfaces() const
 {
-    return m_compositor->m_all_surfaces;
+    Q_D(const QWaylandCompositor);
+    return d->all_surfaces;
 }
 
 QWaylandOutput *QWaylandCompositor::output(QWindow *window) const
 {
-    return m_compositor->output(window);
+    Q_D(const QWaylandCompositor);
+    foreach (QWaylandOutputSpace *outputSpace, d->outputSpaces) {
+        QWaylandOutput *output = outputSpace->output(window);
+        if (output)
+            return output;
+    }
+
+    return Q_NULLPTR;
 }
 
 QWaylandOutput *QWaylandCompositor::primaryOutput() const
 {
-    return m_compositor->primaryOutput();
+    Q_D(const QWaylandCompositor);
+    return d->primaryOutput();
 }
 
 QWaylandOutputSpace *QWaylandCompositor::primaryOutputSpace() const
 {
-    return m_compositor->primaryOutputSpace();
+    Q_D(const QWaylandCompositor);
+    return d->primaryOutputSpace();
 }
 
 void QWaylandCompositor::setPrimaryOutputSpace(QWaylandOutputSpace *outputSpace)
 {
-    m_compositor->setPrimaryOutputSpace(outputSpace);
+    Q_D(QWaylandCompositor);
+
+    Q_ASSERT(!d->outputSpaces.isEmpty());
+    if (d->outputSpaces.first() == outputSpace)
+        return;
+    if (d->outputSpaces.removeOne(outputSpace)) {
+        d->outputSpaces.prepend(outputSpace);
+        primaryOutputSpaceChanged();
+    }
 }
 
 void QWaylandCompositor::addOutputSpace(QWaylandOutputSpace *outputSpace)
 {
-    m_compositor->addOutputSpace(outputSpace);
+    Q_D(QWaylandCompositor);
+    Q_ASSERT(!d->outputSpaces.contains(outputSpace));
+    d->outputSpaces.append(outputSpace);
+    outputSpacesChanged();
 }
 
 void QWaylandCompositor::removeOutputSpace(QWaylandOutputSpace *outputSpace)
 {
-    m_compositor->removeOutputSpace(outputSpace);
+    Q_D(QWaylandCompositor);
+    if (d->outputSpaces.removeOne(outputSpace))
+        outputSpacesChanged();
 }
 
 uint QWaylandCompositor::currentTimeMsecs() const
 {
-    return m_compositor->currentTimeMsecs();
+    Q_D(const QWaylandCompositor);
+    return d->timer.elapsed();
 }
 
 QWaylandOutput *QWaylandCompositor::createOutput(QWaylandOutputSpace *outputSpace,
@@ -204,9 +517,21 @@ QWaylandSurface *QWaylandCompositor::createSurface(QWaylandClient *client, quint
 
 void QWaylandCompositor::cleanupGraphicsResources()
 {
-    m_compositor->cleanupGraphicsResources();
+    Q_D(QWaylandCompositor);
+    qDeleteAll(d->destroyed_surfaces);
+    d->destroyed_surfaces.clear();
+}
+
+void QWaylandCompositor::processWaylandEvents()
+{
+    Q_D(QWaylandCompositor);
+    int ret = wl_event_loop_dispatch(d->loop, 0);
+    if (ret)
+        fprintf(stderr, "wl_event_loop_dispatch error: %d\n", ret);
+    wl_display_flush_clients(d->display);
 }
 
+
 QWaylandInputDevice *QWaylandCompositor::createInputDevice()
 {
     return new QWaylandInputDevice(this);
@@ -227,19 +552,16 @@ QWaylandTouch *QWaylandCompositor::createTouchDevice(QWaylandInputDevice *inputD
     return new QWaylandTouch(inputDevice);
 }
 
-QtWayland::Compositor * QWaylandCompositor::handle() const
-{
-    return m_compositor;
-}
-
 void QWaylandCompositor::setRetainedSelectionEnabled(bool enabled)
 {
-    m_compositor->setRetainedSelectionEnabled(enabled);
+    Q_D(QWaylandCompositor);
+    d->retainSelection = enabled;
 }
 
 bool QWaylandCompositor::retainedSelectionEnabled() const
 {
-    return m_compositor->retainedSelectionEnabled();
+    Q_D(const QWaylandCompositor);
+    return d->retainSelection;
 }
 
 void QWaylandCompositor::retainedSelectionReceived(QMimeData *)
@@ -248,38 +570,52 @@ void QWaylandCompositor::retainedSelectionReceived(QMimeData *)
 
 void QWaylandCompositor::overrideSelection(const QMimeData *data)
 {
-    m_compositor->overrideSelection(data);
+    Q_D(QWaylandCompositor);
+    d->data_device_manager->overrideSelection(*data);
 }
 
 QWaylandInputDevice *QWaylandCompositor::defaultInputDevice() const
 {
-    return m_compositor->defaultInputDevice();
+    Q_D(const QWaylandCompositor);
+    return d->inputDevices.first();
 }
 
 QWaylandDrag *QWaylandCompositor::drag() const
 {
-    return m_compositor->defaultInputDevice()->drag();
+    return defaultInputDevice()->drag();
 }
 
 bool QWaylandCompositor::isDragging() const
 {
-    return m_compositor->isDragging();
+    return false;
 }
 
 void QWaylandCompositor::sendDragMoveEvent(const QPoint &global, const QPoint &local,
                                           QWaylandSurface *surface)
 {
-    m_compositor->sendDragMoveEvent(global, local, surface);
+    Q_UNUSED(global);
+    Q_UNUSED(local);
+    Q_UNUSED(surface);
+//    Drag::instance()->dragMove(global, local, surface);
 }
 
 void QWaylandCompositor::sendDragEndEvent()
 {
-    m_compositor->sendDragEndEvent();
+//    Drag::instance()->dragEnd();
 }
 
 QWaylandInputDevice *QWaylandCompositor::inputDeviceFor(QInputEvent *inputEvent)
 {
-    return m_compositor->inputDeviceFor(inputEvent);
+    Q_D(QWaylandCompositor);
+    QWaylandInputDevice *dev = NULL;
+    for (int i = 0; i < d->inputDevices.size(); i++) {
+        QWaylandInputDevice *candidate = d->inputDevices.at(i);
+        if (candidate->isOwner(inputEvent)) {
+            dev = candidate;
+            break;
+        }
+    }
+    return dev;
 }
 
 QT_END_NAMESPACE
diff --git a/src/compositor/compositor_api/qwaylandcompositor.h b/src/compositor/compositor_api/qwaylandcompositor.h
index 73bd8855f..954422e57 100644
--- a/src/compositor/compositor_api/qwaylandcompositor.h
+++ b/src/compositor/compositor_api/qwaylandcompositor.h
@@ -53,6 +53,7 @@ class QInputEvent;
 class QMimeData;
 class QUrl;
 class QOpenGLContext;
+class QWaylandCompositorPrivate;
 class QWaylandClient;
 class QWaylandSurface;
 class QWaylandInputDevice;
@@ -65,14 +66,10 @@ class QWaylandPointer;
 class QWaylandKeyboard;
 class QWaylandTouch;
 
-namespace QtWayland
-{
-    class Compositor;
-}
-
 class Q_COMPOSITOR_EXPORT QWaylandCompositor : public QObject, public QWaylandExtensionContainer
 {
     Q_OBJECT
+    Q_DECLARE_PRIVATE(QWaylandCompositor)
     Q_PROPERTY(QByteArray socketName READ socketName WRITE setSocketName)
     Q_PROPERTY(QWaylandCompositor::ExtensionFlags extensionFlags READ extensionFlags WRITE setExtensionFlags)
     Q_PROPERTY(bool retainedSelection READ retainedSelectionEnabled WRITE setRetainedSelectionEnabled)
@@ -105,7 +102,7 @@ public:
     void setExtensionFlags(ExtensionFlags flags);
     ExtensionFlags extensionFlags() const;
 
-    ::wl_display *waylandDisplay() const;
+    ::wl_display *display() const;
     uint32_t nextSerial();
 
     QList<QWaylandClient *>clients() const;
@@ -125,8 +122,6 @@ public:
 
     uint currentTimeMsecs() const;
 
-    QtWayland::Compositor *handle() const;
-
     void setRetainedSelectionEnabled(bool enabled);
     bool retainedSelectionEnabled() const;
     void overrideSelection(const QMimeData *data);
@@ -139,12 +134,14 @@ public:
     void sendDragMoveEvent(const QPoint &global, const QPoint &local, QWaylandSurface *surface);
     void sendDragEndEvent();
 
-    void cleanupGraphicsResources();
-
     QWaylandView *createSurfaceView(QWaylandSurface *surface);
 
     QWaylandInputDevice *inputDeviceFor(QInputEvent *inputEvent);
 
+public Q_SLOTS:
+    void cleanupGraphicsResources();
+    void processWaylandEvents();
+
 Q_SIGNALS:
     void surfaceCreated(QWaylandSurface *surface);
     void surfaceAboutToBeDestroyed(QWaylandSurface *surface);
@@ -156,7 +153,6 @@ Q_SIGNALS:
     void outputSpacesChanged();
 
 protected:
-    QWaylandCompositor(QtWayland::Compositor *dptr);
     virtual void retainedSelectionReceived(QMimeData *mimeData);
     virtual QWaylandOutput *createOutput(QWaylandOutputSpace *outputSpace,
                                          QWindow *window,
@@ -168,10 +164,7 @@ protected:
     virtual QWaylandKeyboard *createKeyboardDevice(QWaylandInputDevice *inputDevice);
     virtual QWaylandTouch *createTouchDevice(QWaylandInputDevice *inputDevice);
 
-
-    friend class QtWayland::Compositor;
-    friend class QWaylandOutputSpacePrivate;
-    QtWayland::Compositor *m_compositor;
+    QWaylandCompositor(QWaylandCompositorPrivate *dptr);
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QWaylandCompositor::ExtensionFlags)
diff --git a/src/compositor/compositor_api/qwaylandcompositor_p.h b/src/compositor/compositor_api/qwaylandcompositor_p.h
new file mode 100644
index 000000000..a0462c796
--- /dev/null
+++ b/src/compositor/compositor_api/qwaylandcompositor_p.h
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2014-2015 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWAYLANDCOMPOSITOR_P_H
+#define QWAYLANDCOMPOSITOR_P_H
+
+#include <QtCompositor/qwaylandexport.h>
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/QWaylandOutputSpace>
+#include <QtCore/private/qobject_p.h>
+#include <QtCore/QSet>
+#include <QtCore/QElapsedTimer>
+
+#include <QtCompositor/private/qwayland-server-wayland.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtWayland {
+    class HardwareIntegration;
+    class ClientBufferIntegration;
+    class ServerBufferIntegration;
+    class DataDeviceManager;
+}
+
+class QWindowSystemEventHandler;
+class QWaylandSurface;
+
+class Q_COMPOSITOR_EXPORT QWaylandCompositorPrivate : public QObjectPrivate, public QtWaylandServer::wl_compositor
+{
+public:
+    static QWaylandCompositorPrivate *get(QWaylandCompositor *compositor) { return compositor->d_func(); }
+
+    QWaylandCompositorPrivate(QWaylandCompositor *compositor);
+    ~QWaylandCompositorPrivate();
+
+    void init();
+
+    void destroySurface(QWaylandSurface *surface);
+    void unregisterSurface(QWaylandSurface *surface);
+
+    QWaylandOutput *primaryOutput() const { return primaryOutputSpace()->primaryOutput(); }
+    QWaylandOutputSpace *primaryOutputSpace() const { return outputSpaces.first(); }
+
+    inline QtWayland::ClientBufferIntegration *clientBufferIntegration() const;
+    inline QtWayland::ServerBufferIntegration *serverBufferIntegration() const;
+
+    QtWayland::DataDeviceManager *dataDeviceManager() const { return data_device_manager; }
+    void feedRetainedSelectionData(QMimeData *data);
+
+    QWaylandOutput *callCreateOutput(QWaylandOutputSpace *outputSpace,
+                                 QWindow *window,
+                                 const QString &manufacturer,
+                                 const QString &model)
+    { return q_func()->createOutput(outputSpace, window, manufacturer, model); }
+    QWaylandPointer *callCreatePointerDevice(QWaylandInputDevice *inputDevice)
+    { return q_func()->createPointerDevice(inputDevice); }
+    QWaylandKeyboard *callCreateKeyboardDevice(QWaylandInputDevice *inputDevice)
+    { return q_func()->createKeyboardDevice(inputDevice); }
+    QWaylandTouch *callCreateTouchDevice(QWaylandInputDevice *inputDevice)
+    { return q_func()->createTouchDevice(inputDevice); }
+
+    inline void addClient(QWaylandClient *client);
+    inline void removeClient(QWaylandClient *client);
+protected:
+    void compositor_create_surface(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
+    void compositor_create_region(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
+
+protected:
+    void initializeHardwareIntegration();
+    void initializeExtensions();
+    void initializeDefaultInputDevice();
+
+    void loadClientBufferIntegration();
+    void loadServerBufferIntegration();
+
+    QWaylandCompositor::ExtensionFlags extensions;
+
+    QByteArray socket_name;
+    struct wl_display *display;
+
+    QList<QWaylandInputDevice *> inputDevices;
+
+    QList<QWaylandOutputSpace *> outputSpaces;
+    QList<QWaylandSurface *> all_surfaces;
+    QSet<QWaylandSurface *> destroyed_surfaces;
+
+    QtWayland::DataDeviceManager *data_device_manager;
+
+    QElapsedTimer timer;
+
+    wl_event_loop *loop;
+
+    QList<QWaylandClient *> clients;
+
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    QScopedPointer<QtWayland::HardwareIntegration> hw_integration;
+    QScopedPointer<QtWayland::ClientBufferIntegration> client_buffer_integration;
+    QScopedPointer<QtWayland::ServerBufferIntegration> server_buffer_integration;
+#endif
+
+    QScopedPointer<QWindowSystemEventHandler> eventHandler;
+
+    bool retainSelection;
+    bool initialized;
+
+    Q_DECLARE_PUBLIC(QWaylandCompositor)
+    Q_DISABLE_COPY(QWaylandCompositorPrivate)
+};
+
+QtWayland::ClientBufferIntegration * QWaylandCompositorPrivate::clientBufferIntegration() const
+{
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    return client_buffer_integration.data();
+#else
+    return 0;
+#endif
+}
+
+QtWayland::ServerBufferIntegration * QWaylandCompositorPrivate::serverBufferIntegration() const
+{
+#ifdef QT_COMPOSITOR_WAYLAND_GL
+    return server_buffer_integration.data();
+#else
+    return 0;
+#endif
+}
+
+void QWaylandCompositorPrivate::addClient(QWaylandClient *client)
+{
+    Q_ASSERT(!clients.contains(client));
+    clients.append(client);
+}
+
+void QWaylandCompositorPrivate::removeClient(QWaylandClient *client)
+{
+    Q_ASSERT(clients.contains(client));
+    clients.removeOne(client);
+}
+
+QT_END_NAMESPACE
+
+#endif //QWAYLANDCOMPOSITOR_P_H
diff --git a/src/compositor/compositor_api/qwaylanddrag.cpp b/src/compositor/compositor_api/qwaylanddrag.cpp
index 01c6f38b4..0b3663f4c 100644
--- a/src/compositor/compositor_api/qwaylanddrag.cpp
+++ b/src/compositor/compositor_api/qwaylanddrag.cpp
@@ -38,7 +38,6 @@
 
 #include <private/qobject_p.h>
 
-#include "qwlcompositor_p.h"
 #include "qwlinputdevice_p.h"
 #include "qwldatadevice_p.h"
 #include "qwaylandview.h"
diff --git a/src/compositor/compositor_api/qwaylandinput.cpp b/src/compositor/compositor_api/qwaylandinput.cpp
index 69fe45e96..d95c111fe 100644
--- a/src/compositor/compositor_api/qwaylandinput.cpp
+++ b/src/compositor/compositor_api/qwaylandinput.cpp
@@ -39,7 +39,6 @@
 #include "qwlinputdevice_p.h"
 #include "qwlkeyboard_p.h"
 #include "qwaylandcompositor.h"
-#include "qwlcompositor_p.h"
 #include "qwaylandview.h"
 
 QT_BEGIN_NAMESPACE
diff --git a/src/compositor/compositor_api/qwaylandinputpanel.cpp b/src/compositor/compositor_api/qwaylandinputpanel.cpp
index f4cd2476e..0376a2b96 100644
--- a/src/compositor/compositor_api/qwaylandinputpanel.cpp
+++ b/src/compositor/compositor_api/qwaylandinputpanel.cpp
@@ -45,7 +45,7 @@
 QT_BEGIN_NAMESPACE
 
 QWaylandInputPanel::QWaylandInputPanel(QWaylandCompositor *compositor)
-    : QWaylandExtensionTemplate(*new QWaylandInputPanelPrivate(compositor->handle()))
+    : QWaylandExtensionTemplate(*new QWaylandInputPanelPrivate(compositor))
 {
 }
 
diff --git a/src/compositor/compositor_api/qwaylandinputpanel.h b/src/compositor/compositor_api/qwaylandinputpanel.h
index 1e5953360..70e2246dc 100644
--- a/src/compositor/compositor_api/qwaylandinputpanel.h
+++ b/src/compositor/compositor_api/qwaylandinputpanel.h
@@ -49,10 +49,6 @@ class QWaylandCompositor;
 class QWaylandInputPanelPrivate;
 class QWaylandSurface;
 
-namespace QtWayland {
-class InputPanel;
-}
-
 class Q_COMPOSITOR_EXPORT QWaylandInputPanel : public QWaylandExtensionTemplate<QWaylandInputPanel>
 {
     Q_OBJECT
diff --git a/src/compositor/compositor_api/qwaylandoutput.cpp b/src/compositor/compositor_api/qwaylandoutput.cpp
index e4865d163..5a77912d1 100644
--- a/src/compositor/compositor_api/qwaylandoutput.cpp
+++ b/src/compositor/compositor_api/qwaylandoutput.cpp
@@ -46,7 +46,6 @@
 #include <QtGui/QExposeEvent>
 #include <private/qobject_p.h>
 
-#include "wayland_wrapper/qwlcompositor_p.h"
 #include "wayland_wrapper/qwloutput_p.h"
 
 QT_BEGIN_NAMESPACE
diff --git a/src/compositor/compositor_api/qwaylandoutputspace_p.h b/src/compositor/compositor_api/qwaylandoutputspace_p.h
index b0f33efbd..c10022ee9 100644
--- a/src/compositor/compositor_api/qwaylandoutputspace_p.h
+++ b/src/compositor/compositor_api/qwaylandoutputspace_p.h
@@ -42,6 +42,7 @@
 #include "qwaylandoutputspace.h"
 #include "qwaylandcompositor.h"
 #include "wayland_wrapper/qwloutput_p.h"
+#include <QtCompositor/private/qwaylandcompositor_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -85,7 +86,7 @@ public:
                                        bool primary)
     {
         Q_Q(QWaylandOutputSpace);
-        QWaylandOutput *output = compositor->createOutput(q, window, manufacturer, model);
+        QWaylandOutput *output = QWaylandCompositorPrivate::get(compositor)->callCreateOutput(q, window, manufacturer, model);
         addOutput(output, primary);
         return output;
     }
diff --git a/src/compositor/compositor_api/qwaylandquickcompositor.cpp b/src/compositor/compositor_api/qwaylandquickcompositor.cpp
index 6ff8374e3..7c600dbd8 100644
--- a/src/compositor/compositor_api/qwaylandquickcompositor.cpp
+++ b/src/compositor/compositor_api/qwaylandquickcompositor.cpp
@@ -35,8 +35,6 @@
 **
 ****************************************************************************/
 
-#include <QtCompositor/private/qwlcompositor_p.h>
-
 #include <QtQml/QQmlEngine>
 
 #include "qwaylandclient.h"
diff --git a/src/compositor/compositor_api/qwaylandquickitem.cpp b/src/compositor/compositor_api/qwaylandquickitem.cpp
index 376ea0582..e46144426 100644
--- a/src/compositor/compositor_api/qwaylandquickitem.cpp
+++ b/src/compositor/compositor_api/qwaylandquickitem.cpp
@@ -39,7 +39,6 @@
 #include <QtCompositor/qwaylandcompositor.h>
 #include <QtCompositor/qwaylandinput.h>
 #include <QtCompositor/qwaylandbufferref.h>
-#include <QtCompositor/private/qwlcompositor_p.h>
 #include <QtCompositor/private/qwlclientbufferintegration_p.h>
 
 #include <QtGui/QKeyEvent>
diff --git a/src/compositor/compositor_api/qwaylandsurface.cpp b/src/compositor/compositor_api/qwaylandsurface.cpp
index fdacee958..cf0a7cd85 100644
--- a/src/compositor/compositor_api/qwaylandsurface.cpp
+++ b/src/compositor/compositor_api/qwaylandsurface.cpp
@@ -40,7 +40,6 @@
 
 #include <private/qobject_p.h>
 
-#include "wayland_wrapper/qwlcompositor_p.h"
 #include "wayland_wrapper/qwlinputdevice_p.h"
 #include "wayland_wrapper/qwldatadevice_p.h"
 #include "wayland_wrapper/qwldatadevicemanager_p.h"
@@ -49,10 +48,13 @@
 #include "extensions/qwlextendedsurface_p.h"
 #include "extensions/qwlsubsurface_p.h"
 
-#include "qwaylandcompositor.h"
-#include "qwaylandclient.h"
-#include "qwaylandview_p.h"
-#include "qwaylandbufferref.h"
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/QWaylandClient>
+#include <QtCompositor/QWaylandView>
+#include <QtCompositor/QWaylandBufferRef>
+
+#include <QtCompositor/private/qwaylandcompositor_p.h>
+#include <QtCompositor/private/qwaylandview_p.h>
 
 #include <QtGui/QGuiApplication>
 #include <QtGui/QScreen>
@@ -350,7 +352,7 @@ QWaylandSurface::QWaylandSurface(QWaylandSurfacePrivate *dptr)
 QWaylandSurface::~QWaylandSurface()
 {
     Q_D(QWaylandSurface);
-    d->m_compositor->handle()->unregisterSurface(this);
+    QWaylandCompositorPrivate::get(d->m_compositor)->unregisterSurface(this);
     d->notifyViewsAboutDestruction();
 }
 
@@ -447,7 +449,7 @@ void QWaylandSurface::updateSelection()
     if (inputDevice) {
         const QtWayland::DataDevice *dataDevice = QWaylandInputDevicePrivate::get(inputDevice)->dataDevice();
         if (dataDevice) {
-            d->compositor()->handle()->dataDeviceManager()->offerRetainedSelection(
+            QWaylandCompositorPrivate::get(d->compositor())->dataDeviceManager()->offerRetainedSelection(
                         dataDevice->resourceMap().value(d->resource()->client())->handle);
         }
     }
@@ -463,7 +465,7 @@ void QWaylandSurface::deref()
 {
     Q_D(QWaylandSurface);
     if (--d->refCount == 0)
-        compositor()->handle()->destroySurface(this);
+        QWaylandCompositorPrivate::get(compositor())->destroySurface(this);
 }
 
 QWaylandView *QWaylandSurface::throttlingView() const
diff --git a/src/compositor/compositor_api/qwaylandtouch.cpp b/src/compositor/compositor_api/qwaylandtouch.cpp
index b00706323..dcce43f92 100644
--- a/src/compositor/compositor_api/qwaylandtouch.cpp
+++ b/src/compositor/compositor_api/qwaylandtouch.cpp
@@ -63,7 +63,7 @@ void QWaylandDefaultTouchGrabber::down(uint32_t time, int touch_id, const QPoint
     if (!touch->focusResource() || !touch->mouseFocus())
         return;
 
-    uint32_t serial = wl_display_next_serial(touch->compositor()->waylandDisplay());
+    uint32_t serial = touch->compositor()->nextSerial();
 
     wl_touch_send_down(touch->focusResource(), serial, time, touch->mouseFocus()->surfaceResource(), touch_id,
                        wl_fixed_from_double(position.x()), wl_fixed_from_double(position.y()));
diff --git a/src/compositor/extensions/qwaylandwindowmanagerextension.cpp b/src/compositor/extensions/qwaylandwindowmanagerextension.cpp
index 80ccd02e1..64aff1de7 100644
--- a/src/compositor/extensions/qwaylandwindowmanagerextension.cpp
+++ b/src/compositor/extensions/qwaylandwindowmanagerextension.cpp
@@ -54,7 +54,7 @@ QWaylandWindowManagerExtensionPrivate::QWaylandWindowManagerExtensionPrivate(QWa
     , m_showIsFullScreen(false)
     , m_compositor(compositor)
 {
-    init(compositor->waylandDisplay(), 1);
+    init(compositor->display(), 1);
 }
 
 void QWaylandWindowManagerExtension::setShowIsFullScreen(bool value)
diff --git a/src/compositor/extensions/qwlextendedsurface.cpp b/src/compositor/extensions/qwlextendedsurface.cpp
index 21292c14d..51b49d254 100644
--- a/src/compositor/extensions/qwlextendedsurface.cpp
+++ b/src/compositor/extensions/qwlextendedsurface.cpp
@@ -36,15 +36,15 @@
 
 #include "qwlextendedsurface_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-SurfaceExtensionGlobal::SurfaceExtensionGlobal(Compositor *compositor)
-    : QWaylandExtensionTemplate(compositor->waylandCompositor())
-    , QtWaylandServer::qt_surface_extension(compositor->wl_display(), 1)
+SurfaceExtensionGlobal::SurfaceExtensionGlobal(QWaylandCompositor *compositor)
+    : QWaylandExtensionTemplate(compositor)
+    , QtWaylandServer::qt_surface_extension(compositor->display(), 1)
 {
 }
 
diff --git a/src/compositor/extensions/qwlextendedsurface_p.h b/src/compositor/extensions/qwlextendedsurface_p.h
index 052ecf5e4..0153303f8 100644
--- a/src/compositor/extensions/qwlextendedsurface_p.h
+++ b/src/compositor/extensions/qwlextendedsurface_p.h
@@ -49,16 +49,15 @@
 
 QT_BEGIN_NAMESPACE
 
+class QWaylandCompositor;
 class QWaylandSurface;
 
 namespace QtWayland {
 
-class Compositor;
-
 class SurfaceExtensionGlobal : public QWaylandExtensionTemplate<SurfaceExtensionGlobal>, public QtWaylandServer::qt_surface_extension
 {
 public:
-    SurfaceExtensionGlobal(Compositor *compositor);
+    SurfaceExtensionGlobal(QWaylandCompositor *compositor);
 
 private:
     void surface_extension_get_extended_surface(Resource *resource,
diff --git a/src/compositor/extensions/qwlinputpanel.cpp b/src/compositor/extensions/qwlinputpanel.cpp
index cc4836bc7..2aaffae3e 100644
--- a/src/compositor/extensions/qwlinputpanel.cpp
+++ b/src/compositor/extensions/qwlinputpanel.cpp
@@ -37,8 +37,8 @@
 #include "qwlinputpanel_p.h"
 
 #include <QtCompositor/qwaylandinputpanel.h>
+#include <QtCompositor/QWaylandCompositor>
 
-#include "qwlcompositor_p.h"
 #include "qwlinputdevice_p.h"
 #include "qwlinputmethod_p.h"
 #include "qwlinputpanelsurface_p.h"
@@ -46,15 +46,15 @@
 
 QT_BEGIN_NAMESPACE
 
-QWaylandInputPanelPrivate::QWaylandInputPanelPrivate(QtWayland::Compositor *compositor)
-    : QWaylandExtensionTemplatePrivate(compositor->waylandCompositor())
+QWaylandInputPanelPrivate::QWaylandInputPanelPrivate(QWaylandCompositor *compositor)
+    : QWaylandExtensionTemplatePrivate(compositor)
     , QtWaylandServer::wl_input_panel()
     , m_compositor(compositor)
     , m_focus()
     , m_inputPanelVisible(false)
     , m_cursorRectangle()
 {
-    init(compositor->wl_display(), 1);
+    init(compositor->display(), 1);
 }
 
 QWaylandInputPanelPrivate::~QWaylandInputPanelPrivate()
diff --git a/src/compositor/extensions/qwlinputpanel_p.h b/src/compositor/extensions/qwlinputpanel_p.h
index 65718892b..1cb6f383b 100644
--- a/src/compositor/extensions/qwlinputpanel_p.h
+++ b/src/compositor/extensions/qwlinputpanel_p.h
@@ -49,7 +49,6 @@
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
-class Compositor;
 class TextInput;
 }
 
@@ -58,7 +57,7 @@ class Q_COMPOSITOR_EXPORT QWaylandInputPanelPrivate : public QWaylandExtensionTe
 {
     Q_DECLARE_PUBLIC(QWaylandInputPanel)
 public:
-    QWaylandInputPanelPrivate(QtWayland::Compositor *compositor);
+    QWaylandInputPanelPrivate(QWaylandCompositor *compositor);
     ~QWaylandInputPanelPrivate();
 
     QWaylandInputPanel *waylandInputPanel() const;
@@ -77,7 +76,7 @@ protected:
     void input_panel_get_input_panel_surface(Resource *resource, uint32_t id, struct ::wl_resource *surface) Q_DECL_OVERRIDE;
 
 private:
-    QtWayland::Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
 
     QWaylandSurface *m_focus;
     bool m_inputPanelVisible;
diff --git a/src/compositor/extensions/qwlqtkey.cpp b/src/compositor/extensions/qwlqtkey.cpp
index 875524bf5..90bb83b37 100644
--- a/src/compositor/extensions/qwlqtkey.cpp
+++ b/src/compositor/extensions/qwlqtkey.cpp
@@ -43,9 +43,9 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-QtKeyExtensionGlobal::QtKeyExtensionGlobal(Compositor *compositor)
-    : QWaylandExtensionTemplate(compositor->waylandCompositor())
-    , QtWaylandServer::qt_key_extension(compositor->wl_display(), 2)
+QtKeyExtensionGlobal::QtKeyExtensionGlobal(QWaylandCompositor *compositor)
+    : QWaylandExtensionTemplate(compositor)
+    , QtWaylandServer::qt_key_extension(compositor->display(), 2)
     , m_compositor(compositor)
 {
 }
diff --git a/src/compositor/extensions/qwlqtkey_p.h b/src/compositor/extensions/qwlqtkey_p.h
index 67474ffc6..decb1975d 100644
--- a/src/compositor/extensions/qwlqtkey_p.h
+++ b/src/compositor/extensions/qwlqtkey_p.h
@@ -37,16 +37,15 @@
 #ifndef WLQTKEY_H
 #define WLQTKEY_H
 
-#include  <private/qwlcompositor_p.h>
-
 #include "wayland-util.h"
 
+#include <QtCompositor/QWaylandExtensionTemplate>
+#include <QtCompositor/QWaylandCompositor>
 #include <QtCompositor/private/qwayland-server-qtkey-extension.h>
 
 QT_BEGIN_NAMESPACE
 
 class QWaylandSurface;
-class Compositor;
 class QKeyEvent;
 
 namespace QtWayland {
@@ -55,12 +54,12 @@ class QtKeyExtensionGlobal : public QWaylandExtensionTemplate<QtKeyExtensionGlob
 {
     Q_OBJECT
 public:
-    QtKeyExtensionGlobal(Compositor *compositor);
+    QtKeyExtensionGlobal(QWaylandCompositor *compositor);
 
     bool postQtKeyEvent(QKeyEvent *event, QWaylandSurface *surface);
 
 private:
-    Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
 };
 
 }
diff --git a/src/compositor/extensions/qwlqttouch.cpp b/src/compositor/extensions/qwlqttouch.cpp
index 9c476dbf7..5f0c60b9c 100644
--- a/src/compositor/extensions/qwlqttouch.cpp
+++ b/src/compositor/extensions/qwlqttouch.cpp
@@ -45,9 +45,9 @@ namespace QtWayland {
 
 static const int maxRawPos = 24;
 
-TouchExtensionGlobal::TouchExtensionGlobal(Compositor *compositor)
-    : QWaylandExtensionTemplate(compositor->waylandCompositor())
-    , QtWaylandServer::qt_touch_extension(compositor->wl_display(), 1)
+TouchExtensionGlobal::TouchExtensionGlobal(QWaylandCompositor *compositor)
+    : QWaylandExtensionTemplate(compositor)
+    , QtWaylandServer::qt_touch_extension(compositor->display(), 1)
     , m_compositor(compositor)
     , m_flags(0)
     , m_resources()
diff --git a/src/compositor/extensions/qwlqttouch_p.h b/src/compositor/extensions/qwlqttouch_p.h
index e7860343b..46afebfaa 100644
--- a/src/compositor/extensions/qwlqttouch_p.h
+++ b/src/compositor/extensions/qwlqttouch_p.h
@@ -37,13 +37,13 @@
 #ifndef WLTOUCH_H
 #define WLTOUCH_H
 
-#include <private/qwlcompositor_p.h>
 #include <QtCompositor/private/qwayland-server-touch-extension.h>
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/QWaylandExtensionTemplate>
 #include "wayland-util.h"
 
 QT_BEGIN_NAMESPACE
 
-class Compositor;
 class Surface;
 class QTouchEvent;
 class QWaylandView;
@@ -62,7 +62,7 @@ public:
     };
     Q_DECLARE_FLAGS(BehaviorFlags, BehaviorFlag)
 
-    TouchExtensionGlobal(Compositor *compositor);
+    TouchExtensionGlobal(QWaylandCompositor *compositor);
     ~TouchExtensionGlobal();
 
     bool postTouchEvent(QTouchEvent *event, QWaylandView *view);
@@ -78,7 +78,7 @@ protected:
     void touch_extension_destroy_resource(Resource *resource) Q_DECL_OVERRIDE;
 
 private:
-    Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
     BehaviorFlags m_flags;
     QList<Resource *> m_resources;
     QVector<float> m_posData;
diff --git a/src/compositor/extensions/qwlshellsurface.cpp b/src/compositor/extensions/qwlshellsurface.cpp
index 3e0535ca1..fff4e888a 100644
--- a/src/compositor/extensions/qwlshellsurface.cpp
+++ b/src/compositor/extensions/qwlshellsurface.cpp
@@ -37,7 +37,8 @@
 
 #include "qwlshellsurface_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
+
 #include "qwloutput_p.h"
 #include "qwlinputdevice_p.h"
 #include "qwlsubsurface_p.h"
@@ -57,7 +58,7 @@ namespace QtWayland {
 
 Shell::Shell(QWaylandCompositor *compositor)
     : QWaylandExtensionTemplate(compositor)
-    , wl_shell(compositor->waylandDisplay(), 1)
+    , wl_shell(compositor->display(), 1)
 {
 }
 
@@ -107,7 +108,7 @@ void ShellSurface::sendConfigure(uint32_t edges, int32_t width, int32_t height)
 
 void ShellSurface::ping()
 {
-    uint32_t serial = wl_display_next_serial(m_surface->compositor()->waylandDisplay());
+    uint32_t serial = m_surface->compositor()->nextSerial();
     ping(serial);
 }
 
diff --git a/src/compositor/extensions/qwlsubsurface.cpp b/src/compositor/extensions/qwlsubsurface.cpp
index 8932748f7..91de26149 100644
--- a/src/compositor/extensions/qwlsubsurface.cpp
+++ b/src/compositor/extensions/qwlsubsurface.cpp
@@ -36,7 +36,7 @@
 
 #include "qwlsubsurface_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 #include "qwaylandsurface.h"
 #include "qwaylandview.h"
 
@@ -46,7 +46,7 @@ namespace QtWayland {
 
 SubSurfaceExtensionGlobal::SubSurfaceExtensionGlobal(QWaylandCompositor *compositor)
     : QWaylandExtensionTemplate(compositor)
-    , qt_sub_surface_extension(compositor->waylandDisplay(), 1)
+    , qt_sub_surface_extension(compositor->display(), 1)
     , m_compositor(compositor)
 {
 }
diff --git a/src/compositor/extensions/qwltextinput.cpp b/src/compositor/extensions/qwltextinput.cpp
index 465972d8f..d9e1774bb 100644
--- a/src/compositor/extensions/qwltextinput.cpp
+++ b/src/compositor/extensions/qwltextinput.cpp
@@ -36,11 +36,12 @@
 
 #include "qwltextinput_p.h"
 
-#include "qwlcompositor_p.h"
 #include "qwlinputdevice_p.h"
 #include "qwlinputmethod_p.h"
 #include "qwlinputmethodcontext_p.h"
 #include "qwlinputpanel_p.h"
+#include <QtCompositor/QWaylandInputPanel>
+#include <QtCompositor/QWaylandCompositor>
 
 #include <algorithm>
 
@@ -48,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-TextInput::TextInput(QWaylandExtensionContainer *container, Compositor *compositor, struct ::wl_client *client, int id)
+TextInput::TextInput(QWaylandExtensionContainer *container, QWaylandCompositor *compositor, struct ::wl_client *client, int id)
     : QWaylandExtensionTemplate(container)
     , wl_text_input(client, id, 1)
     , m_compositor(compositor)
@@ -129,7 +130,7 @@ void TextInput::text_input_show_input_panel(Resource *)
     m_inputPanelVisible = true;
 
     if (std::find_if(m_activeInputMethods.cbegin(), m_activeInputMethods.cend(), isInputMethodBound) != m_activeInputMethods.cend()){
-        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor->waylandCompositor());
+        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor);
         if (panel)
             panel->setInputPanelVisible(true);
     }
@@ -140,7 +141,7 @@ void TextInput::text_input_hide_input_panel(Resource *)
     m_inputPanelVisible = false;
 
     if (std::find_if(m_activeInputMethods.cbegin(), m_activeInputMethods.cend(), isInputMethodBound) != m_activeInputMethods.cend()) {
-        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor->waylandCompositor());
+        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor);
         if (panel)
             panel->setInputPanelVisible(false);
     }
@@ -151,7 +152,7 @@ void TextInput::text_input_set_cursor_rectangle(Resource *, int32_t x, int32_t y
     m_cursorRectangle = QRect(x, y, width, height);
 
     if (!m_activeInputMethods.isEmpty()) {
-        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor->waylandCompositor());
+        QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::findIn(m_compositor);
         if (panel)
             panel->setCursorRectangle(m_cursorRectangle);
     }
diff --git a/src/compositor/extensions/qwltextinput_p.h b/src/compositor/extensions/qwltextinput_p.h
index bd4b212f4..8f51622fd 100644
--- a/src/compositor/extensions/qwltextinput_p.h
+++ b/src/compositor/extensions/qwltextinput_p.h
@@ -45,16 +45,16 @@
 QT_BEGIN_NAMESPACE
 
 class QWaylandSurface;
+class QWaylandCompositor;
 
 namespace QtWayland {
 
-class Compositor;
 class InputMethod;
 
 class TextInput : public QWaylandExtensionTemplate<TextInput>, public QtWaylandServer::wl_text_input
 {
 public:
-    explicit TextInput(QWaylandExtensionContainer *container, Compositor *compositor, struct ::wl_client *client, int id);
+    explicit TextInput(QWaylandExtensionContainer *container, QWaylandCompositor *compositor, struct ::wl_client *client, int id);
 
     QWaylandSurface *focus() const;
 
@@ -79,7 +79,7 @@ protected:
     void text_input_invoke_action(Resource *resource, uint32_t button, uint32_t index) Q_DECL_OVERRIDE;
 
 private:
-    Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
     QList<InputMethod*> m_activeInputMethods;
     QWaylandSurface *m_focus;
 
diff --git a/src/compositor/extensions/qwltextinputmanager.cpp b/src/compositor/extensions/qwltextinputmanager.cpp
index b45a7e385..cbffbf126 100644
--- a/src/compositor/extensions/qwltextinputmanager.cpp
+++ b/src/compositor/extensions/qwltextinputmanager.cpp
@@ -36,16 +36,16 @@
 
 #include "qwltextinputmanager_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 #include "qwltextinput_p.h"
 
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-TextInputManager::TextInputManager(Compositor *compositor)
-    : QWaylandExtensionTemplate(compositor->waylandCompositor())
-    , QtWaylandServer::wl_text_input_manager(compositor->wl_display(), 1)
+TextInputManager::TextInputManager(QWaylandCompositor *compositor)
+    : QWaylandExtensionTemplate(compositor)
+    , QtWaylandServer::wl_text_input_manager(compositor->display(), 1)
     , m_compositor(compositor)
 {
 }
diff --git a/src/compositor/extensions/qwltextinputmanager_p.h b/src/compositor/extensions/qwltextinputmanager_p.h
index 234d4ab1e..1702166cd 100644
--- a/src/compositor/extensions/qwltextinputmanager_p.h
+++ b/src/compositor/extensions/qwltextinputmanager_p.h
@@ -42,22 +42,22 @@
 
 QT_BEGIN_NAMESPACE
 
-namespace QtWayland {
+class QWaylandCompositor;
 
-class Compositor;
+namespace QtWayland {
 
 class TextInputManager : public QWaylandExtensionTemplate<TextInputManager>, public QtWaylandServer::wl_text_input_manager, public QWaylandExtensionContainer
 {
     Q_OBJECT
 public:
-    TextInputManager(Compositor *compositor);
+    TextInputManager(QWaylandCompositor *compositor);
     ~TextInputManager();
 
 protected:
     void text_input_manager_create_text_input(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
 
 private:
-    Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
 };
 
 } // namespace QtWayland
diff --git a/src/compositor/hardware_integration/qwlclientbufferintegration_p.h b/src/compositor/hardware_integration/qwlclientbufferintegration_p.h
index 9d684553a..b7614fd72 100644
--- a/src/compositor/hardware_integration/qwlclientbufferintegration_p.h
+++ b/src/compositor/hardware_integration/qwlclientbufferintegration_p.h
@@ -59,7 +59,7 @@ public:
 
     void setCompositor(QWaylandCompositor *compositor) { m_compositor = compositor; }
 
-    virtual void initializeHardware(QtWayland::Display *waylandDisplay) = 0;
+    virtual void initializeHardware(struct ::wl_display *display) = 0;
 
     // Used when the hardware integration wants to provide its own texture for a given buffer.
     // In most cases the compositor creates and manages the texture so this is not needed.
diff --git a/src/compositor/hardware_integration/qwlhwintegration.cpp b/src/compositor/hardware_integration/qwlhwintegration.cpp
index f9d0377e7..68ab0d890 100644
--- a/src/compositor/hardware_integration/qwlhwintegration.cpp
+++ b/src/compositor/hardware_integration/qwlhwintegration.cpp
@@ -36,14 +36,14 @@
 
 #include "qwlhwintegration_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-HardwareIntegration::HardwareIntegration(Compositor *compositor)
-    : qt_hardware_integration(compositor->wl_display(), 1)
+HardwareIntegration::HardwareIntegration(QWaylandCompositor *compositor)
+    : qt_hardware_integration(compositor->display(), 1)
 {
 }
 void HardwareIntegration::setClientBufferIntegration(const QString &name)
diff --git a/src/compositor/hardware_integration/qwlhwintegration_p.h b/src/compositor/hardware_integration/qwlhwintegration_p.h
index f615aa7f0..42c6e685a 100644
--- a/src/compositor/hardware_integration/qwlhwintegration_p.h
+++ b/src/compositor/hardware_integration/qwlhwintegration_p.h
@@ -43,14 +43,14 @@
 
 QT_BEGIN_NAMESPACE
 
-namespace QtWayland {
+class QWaylandCompositor;
 
-class Compositor;
+namespace QtWayland {
 
 class HardwareIntegration : public QtWaylandServer::qt_hardware_integration
 {
 public:
-    HardwareIntegration(Compositor *compositor);
+    HardwareIntegration(QWaylandCompositor *compositor);
 
     void setClientBufferIntegration(const QString &name);
     void setServerBufferIntegration(const QString &name);
diff --git a/src/compositor/wayland_wrapper/qwlcompositor.cpp b/src/compositor/wayland_wrapper/qwlcompositor.cpp
deleted file mode 100644
index 65b669a02..000000000
--- a/src/compositor/wayland_wrapper/qwlcompositor.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
-**
-** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL3$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qwlcompositor_p.h"
-
-#include "qwaylandinput.h"
-#include "qwldisplay_p.h"
-#include "qwloutput_p.h"
-#include "qwaylandsurface_p.h"
-#include "qwaylandclient.h"
-#include "qwaylandcompositor.h"
-#include "qwldatadevicemanager_p.h"
-#include "qwldatadevice_p.h"
-#include "qwlextendedsurface_p.h"
-#include "qwlsubsurface_p.h"
-#include "qwlshellsurface_p.h"
-#include "qwlqttouch_p.h"
-#include "qwlqtkey_p.h"
-#include "qwlinputdevice_p.h"
-#include "qwlregion_p.h"
-#include "qwlpointer_p.h"
-#include "qwltextinputmanager_p.h"
-#include <QtCompositor/QWaylandInputPanel>
-#include "qwaylandview.h"
-#include "qwaylandshmformathelper.h"
-#include "qwaylandoutput.h"
-#include "qwlkeyboard_p.h"
-
-#include <QWindow>
-#include <QSocketNotifier>
-#include <QScreen>
-#include <qpa/qplatformscreen.h>
-#include <QGuiApplication>
-#include <QDebug>
-
-#include <QtCore/QAbstractEventDispatcher>
-#include <QtGui/private/qguiapplication_p.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stddef.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <sys/mman.h>
-#include <sys/select.h>
-#include <sys/time.h>
-
-#include <wayland-server.h>
-
-#if defined (QT_COMPOSITOR_WAYLAND_GL)
-#include "hardware_integration/qwlhwintegration_p.h"
-#include "hardware_integration/qwlclientbufferintegration_p.h"
-#include "hardware_integration/qwlserverbufferintegration_p.h"
-#endif
-#include "extensions/qwaylandwindowmanagerextension.h"
-
-#include "hardware_integration/qwlclientbufferintegrationfactory_p.h"
-#include "hardware_integration/qwlserverbufferintegrationfactory_p.h"
-
-#include "../shared/qwaylandxkb.h"
-
-QT_BEGIN_NAMESPACE
-
-namespace QtWayland {
-
-class WindowSystemEventHandler : public QWindowSystemEventHandler
-{
-public:
-    WindowSystemEventHandler(Compositor *c) : compositor(c) {}
-    bool sendEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *e) Q_DECL_OVERRIDE
-    {
-        if (e->type == QWindowSystemInterfacePrivate::Key) {
-            QWindowSystemInterfacePrivate::KeyEvent *ke = static_cast<QWindowSystemInterfacePrivate::KeyEvent *>(e);
-            QWaylandKeyboardPrivate *keyb = QWaylandKeyboardPrivate::get(compositor->defaultInputDevice()->keyboard());
-
-            uint32_t code = ke->nativeScanCode;
-            bool isDown = ke->keyType == QEvent::KeyPress;
-
-#ifndef QT_NO_WAYLAND_XKB
-            QString text;
-            Qt::KeyboardModifiers modifiers = QWaylandXkb::modifiers(keyb->xkbState());
-
-            const xkb_keysym_t sym = xkb_state_key_get_one_sym(keyb->xkbState(), code);
-            uint utf32 = xkb_keysym_to_utf32(sym);
-            if (utf32)
-                text = QString::fromUcs4(&utf32, 1);
-            int qtkey = QWaylandXkb::keysymToQtKey(sym, modifiers, text);
-
-            ke->key = qtkey;
-            ke->modifiers = modifiers;
-            ke->nativeVirtualKey = sym;
-            ke->nativeModifiers = keyb->xkbModsMask();
-            ke->unicode = text;
-#endif
-            if (!ke->repeat)
-                keyb->keyEvent(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
-
-            QWindowSystemEventHandler::sendEvent(e);
-
-            if (!ke->repeat) {
-                keyb->updateKeymap();
-                keyb->updateModifierState(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
-            }
-        } else {
-            QWindowSystemEventHandler::sendEvent(e);
-        }
-        return true;
-    }
-
-    Compositor *compositor;
-};
-
-Compositor::Compositor(QWaylandCompositor *qt_compositor)
-    : m_extensions(QWaylandCompositor::DefaultExtensions)
-    , m_display(new Display)
-    , m_current_frame(0)
-    , m_last_queued_buf(-1)
-    , m_qt_compositor(qt_compositor)
-    , m_orientation(Qt::PrimaryOrientation)
-#if defined (QT_COMPOSITOR_WAYLAND_GL)
-    , m_hw_integration(0)
-    , m_client_buffer_integration(0)
-    , m_server_buffer_integration(0)
-#endif
-    , m_eventHandler(new WindowSystemEventHandler(this))
-    , m_retainSelection(false)
-    , m_initialized(false)
-{
-    m_outputSpaces.append(new QWaylandOutputSpace(qt_compositor));
-    m_timer.start();
-
-    QWindowSystemInterfacePrivate::installWindowSystemEventHandler(m_eventHandler.data());
-}
-
-void Compositor::init()
-{
-    QStringList arguments = QCoreApplication::instance()->arguments();
-
-    int socketArg = arguments.indexOf(QLatin1String("--wayland-socket-name"));
-    if (socketArg != -1 && socketArg + 1 < arguments.size())
-        m_socket_name = arguments.at(socketArg + 1).toLocal8Bit();
-
-    wl_compositor::init(m_display->handle(), 3);
-
-    m_data_device_manager =  new DataDeviceManager(this);
-
-    wl_display_init_shm(m_display->handle());
-    QVector<wl_shm_format> formats = QWaylandShmFormatHelper::supportedWaylandFormats();
-    foreach (wl_shm_format format, formats)
-        wl_display_add_shm_format(m_display->handle(), format);
-
-    const char *socketName = 0;
-    if (m_socket_name.size())
-        socketName = m_socket_name.constData();
-    if (wl_display_add_socket(m_display->handle(), socketName)) {
-        qFatal("Fatal: Failed to open server socket\n");
-    }
-
-    m_loop = wl_display_get_event_loop(m_display->handle());
-
-    int fd = wl_event_loop_get_fd(m_loop);
-
-    QSocketNotifier *sockNot = new QSocketNotifier(fd, QSocketNotifier::Read, this);
-    connect(sockNot, SIGNAL(activated(int)), this, SLOT(processWaylandEvents()));
-
-    QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher;
-    connect(dispatcher, SIGNAL(aboutToBlock()), this, SLOT(processWaylandEvents()));
-
-    qRegisterMetaType<SurfaceBuffer*>("SurfaceBuffer*");
-    qRegisterMetaType<QWaylandClient*>("WaylandClient*");
-    qRegisterMetaType<QWaylandSurface*>("WaylandSurface*");
-    qRegisterMetaType<QWaylandView*>("WaylandSurfaceView*");
-    //initialize distancefieldglyphcache here
-
-    initializeHardwareIntegration();
-    initializeExtensions();
-    initializeDefaultInputDevice();
-
-    m_initialized = true;
-}
-
-Compositor::~Compositor()
-{
-    if (!m_destroyed_surfaces.isEmpty())
-        qWarning("QWaylandCompositor::cleanupGraphicsResources() must be called manually");
-    qDeleteAll(m_clients);
-
-    qDeleteAll(m_outputSpaces);
-
-    removeInputDevice(m_default_wayland_input_device);
-    delete m_default_wayland_input_device;
-    delete m_data_device_manager;
-
-    delete m_display;
-}
-
-uint Compositor::currentTimeMsecs() const
-{
-    return m_timer.elapsed();
-}
-
-QWaylandOutput *Compositor::output(QWindow *window) const
-{
-    foreach (QWaylandOutputSpace *outputSpace, m_outputSpaces) {
-        QWaylandOutput *output = outputSpace->output(window);
-        if (output)
-            return output;
-    }
-
-    return Q_NULLPTR;
-}
-
-QWaylandOutput *Compositor::primaryOutput() const
-{
-    return primaryOutputSpace()->primaryOutput();
-}
-
-QWaylandOutputSpace *Compositor::primaryOutputSpace() const
-{
-    Q_ASSERT(!m_outputSpaces.isEmpty());
-    return m_outputSpaces.first();
-}
-
-void Compositor::setPrimaryOutputSpace(QWaylandOutputSpace *outputSpace)
-{
-    Q_ASSERT(!m_outputSpaces.isEmpty());
-    if (m_outputSpaces.first() == outputSpace)
-        return;
-    if (m_outputSpaces.removeOne(outputSpace)) {
-        m_outputSpaces.prepend(outputSpace);
-        waylandCompositor()->primaryOutputSpaceChanged();
-    }
-}
-
-void Compositor::addOutputSpace(QWaylandOutputSpace *outputSpace)
-{
-    Q_ASSERT(!m_outputSpaces.contains(outputSpace));
-    m_outputSpaces.append(outputSpace);
-    waylandCompositor()->outputSpacesChanged();
-}
-
-void Compositor::removeOutputSpace(QWaylandOutputSpace *outputSpace)
-{
-    if (m_outputSpaces.removeOne(outputSpace))
-        waylandCompositor()->outputSpacesChanged();
-}
-
-void Compositor::processWaylandEvents()
-{
-    int ret = wl_event_loop_dispatch(m_loop, 0);
-    if (ret)
-        fprintf(stderr, "wl_event_loop_dispatch error: %d\n", ret);
-    wl_display_flush_clients(m_display->handle());
-}
-
-void Compositor::destroySurface(QWaylandSurface *surface)
-{
-    waylandCompositor()->surfaceAboutToBeDestroyed(surface);
-
-    m_destroyed_surfaces << surface;
-}
-
-void Compositor::unregisterSurface(QWaylandSurface *surface)
-{
-    if (!m_all_surfaces.removeOne(surface))
-        qWarning("%s Unexpected state. Cant find registered surface\n", Q_FUNC_INFO);
-}
-
-void Compositor::cleanupGraphicsResources()
-{
-    qDeleteAll(m_destroyed_surfaces);
-    m_destroyed_surfaces.clear();
-}
-
-void Compositor::compositor_create_surface(Resource *resource, uint32_t id)
-{
-    QWaylandClient *client = QWaylandClient::fromWlClient(m_qt_compositor, resource->client());
-    QWaylandSurface *surface = m_qt_compositor->createSurface(client, id, resource->version());
-    m_all_surfaces.append(surface);
-    emit m_qt_compositor->surfaceCreated(surface);
-}
-
-void Compositor::compositor_create_region(Resource *resource, uint32_t id)
-{
-    new Region(resource->client(), id);
-}
-
-void Compositor::destroyClient(QWaylandClient *client)
-{
-    if (!client)
-        return;
-
-    QWaylandWindowManagerExtension *wmExtension = QWaylandWindowManagerExtension::findIn(waylandCompositor());
-    if (wmExtension)
-        wmExtension->sendQuitMessage(client->client());
-
-    wl_client_destroy(client->client());
-}
-
-ClientBufferIntegration * Compositor::clientBufferIntegration() const
-{
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    return m_client_buffer_integration.data();
-#else
-    return 0;
-#endif
-}
-
-ServerBufferIntegration * Compositor::serverBufferIntegration() const
-{
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    return m_server_buffer_integration.data();
-#else
-    return 0;
-#endif
-}
-
-void Compositor::initializeHardwareIntegration()
-{
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    if (m_extensions & QWaylandCompositor::HardwareIntegrationExtension)
-        m_hw_integration.reset(new HardwareIntegration(this));
-
-    loadClientBufferIntegration();
-    loadServerBufferIntegration();
-
-    if (m_client_buffer_integration)
-        m_client_buffer_integration->initializeHardware(m_display);
-    if (m_server_buffer_integration)
-        m_server_buffer_integration->initializeHardware(m_qt_compositor);
-#endif
-}
-
-void Compositor::initializeExtensions()
-{
-    if (m_extensions & QWaylandCompositor::SurfaceExtension)
-        new SurfaceExtensionGlobal(this);
-    if (m_extensions & QWaylandCompositor::SubSurfaceExtension)
-        new SubSurfaceExtensionGlobal(waylandCompositor());
-    if (m_extensions & QWaylandCompositor::TouchExtension)
-        new TouchExtensionGlobal(this);
-    if (m_extensions & QWaylandCompositor::QtKeyExtension)
-        new QtKeyExtensionGlobal(this);
-    if (m_extensions & QWaylandCompositor::TextInputExtension) {
-        new TextInputManager(this);
-        new QWaylandInputPanel(waylandCompositor());
-    }
-    if (m_extensions & QWaylandCompositor::WindowManagerExtension)
-        new QWaylandWindowManagerExtension(waylandCompositor());
-}
-
-void Compositor::initializeDefaultInputDevice()
-{
-    m_default_wayland_input_device = m_qt_compositor->createInputDevice();
-    registerInputDevice(m_default_wayland_input_device);
-}
-
-QList<QWaylandClient *> Compositor::clients() const
-{
-    return m_clients;
-}
-
-QWaylandCompositor::ExtensionFlags Compositor::extensions() const
-{
-    return m_extensions;
-}
-
-QWaylandInputDevice *Compositor::defaultInputDevice()
-{
-    // The list gets prepended so that default is the last element
-    return m_inputDevices.last();
-}
-
-DataDeviceManager *Compositor::dataDeviceManager() const
-{
-    return m_data_device_manager;
-}
-
-void Compositor::setRetainedSelectionEnabled(bool enabled)
-{
-    m_retainSelection = enabled;
-}
-
-bool Compositor::retainedSelectionEnabled() const
-{
-    return m_retainSelection;
-}
-
-void Compositor::feedRetainedSelectionData(QMimeData *data)
-{
-    if (m_retainSelection)
-        m_qt_compositor->retainedSelectionReceived(data);
-}
-
-void Compositor::overrideSelection(const QMimeData *data)
-{
-    m_data_device_manager->overrideSelection(*data);
-}
-
-bool Compositor::isDragging() const
-{
-    return false;
-}
-
-void Compositor::sendDragMoveEvent(const QPoint &global, const QPoint &local,
-                                   QWaylandSurface *surface)
-{
-    Q_UNUSED(global);
-    Q_UNUSED(local);
-    Q_UNUSED(surface);
-//    Drag::instance()->dragMove(global, local, surface);
-}
-
-void Compositor::sendDragEndEvent()
-{
-//    Drag::instance()->dragEnd();
-}
-
-void Compositor::loadClientBufferIntegration()
-{
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    QStringList keys = ClientBufferIntegrationFactory::keys();
-    QString targetKey;
-    QByteArray clientBufferIntegration = qgetenv("QT_WAYLAND_HARDWARE_INTEGRATION");
-    if (clientBufferIntegration.isEmpty())
-        clientBufferIntegration = qgetenv("QT_WAYLAND_CLIENT_BUFFER_INTEGRATION");
-    if (keys.contains(QString::fromLocal8Bit(clientBufferIntegration.constData()))) {
-        targetKey = QString::fromLocal8Bit(clientBufferIntegration.constData());
-    } else if (keys.contains(QString::fromLatin1("wayland-egl"))) {
-        targetKey = QString::fromLatin1("wayland-egl");
-    } else if (!keys.isEmpty()) {
-        targetKey = keys.first();
-    }
-
-    if (!targetKey.isEmpty()) {
-        m_client_buffer_integration.reset(ClientBufferIntegrationFactory::create(targetKey, QStringList()));
-        if (m_client_buffer_integration) {
-            m_client_buffer_integration->setCompositor(m_qt_compositor);
-            if (m_hw_integration)
-                m_hw_integration->setClientBufferIntegration(targetKey);
-        }
-    }
-    //BUG: if there is no client buffer integration, bad things will happen when opengl is used
-#endif
-}
-
-void Compositor::loadServerBufferIntegration()
-{
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    QStringList keys = ServerBufferIntegrationFactory::keys();
-    QString targetKey;
-    QByteArray serverBufferIntegration = qgetenv("QT_WAYLAND_SERVER_BUFFER_INTEGRATION");
-    if (keys.contains(QString::fromLocal8Bit(serverBufferIntegration.constData()))) {
-        targetKey = QString::fromLocal8Bit(serverBufferIntegration.constData());
-    }
-    if (!targetKey.isEmpty()) {
-        m_server_buffer_integration.reset(ServerBufferIntegrationFactory::create(targetKey, QStringList()));
-        if (m_hw_integration)
-            m_hw_integration->setServerBufferIntegration(targetKey);
-    }
-#endif
-}
-
-void Compositor::registerInputDevice(QWaylandInputDevice *device)
-{
-    // The devices get prepended as the first input device that gets added
-    // is assumed to be the default and it will claim to accept all the input
-    // events if asked
-    m_inputDevices.prepend(device);
-}
-
-void Compositor::removeInputDevice(QWaylandInputDevice *device)
-{
-    m_inputDevices.removeOne(device);
-}
-
-QWaylandInputDevice *Compositor::inputDeviceFor(QInputEvent *inputEvent)
-{
-    QWaylandInputDevice *dev = NULL;
-    for (int i = 0; i < m_inputDevices.size(); i++) {
-        QWaylandInputDevice *candidate = m_inputDevices.at(i);
-        if (candidate->isOwner(inputEvent)) {
-            dev = candidate;
-            break;
-        }
-    }
-    return dev;
-}
-
-} // namespace Wayland
-
-QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/qwlcompositor_p.h b/src/compositor/wayland_wrapper/qwlcompositor_p.h
deleted file mode 100644
index 4881addae..000000000
--- a/src/compositor/wayland_wrapper/qwlcompositor_p.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014-2015 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
-**
-** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL3$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef WL_COMPOSITOR_H
-#define WL_COMPOSITOR_H
-
-#include <QtCompositor/qwaylandexport.h>
-#include <QtCompositor/qwaylandcompositor.h>
-
-#include <QtCompositor/private/qwayland-server-wayland.h>
-
-#include <QtCore/QElapsedTimer>
-#include <QtCore/QSet>
-
-#include <private/qwldisplay_p.h>
-
-#include <wayland-server.h>
-
-QT_BEGIN_NAMESPACE
-
-class QWaylandClient;
-class QWaylandClientPrivate;
-class QInputEvent;
-
-class QWaylandCompositor;
-class QWaylandInputDevice;
-class WindowManagerServerIntegration;
-class QMimeData;
-class QPlatformScreenBuffer;
-class QWaylandSurface;
-class QWindowSystemEventHandler;
-
-namespace QtWayland {
-
-class Surface;
-class SurfaceBuffer;
-class InputDevice;
-class DataDeviceManager;
-class SurfaceExtensionGlobal;
-class TouchExtensionGlobal;
-class QtKeyExtensionGlobal;
-class TextInputManager;
-class InputPanel;
-class HardwareIntegration;
-class ClientBufferIntegration;
-class ServerBufferIntegration;
-
-class Q_COMPOSITOR_EXPORT Compositor : public QObject, public QtWaylandServer::wl_compositor
-{
-    Q_OBJECT
-
-public:
-    Compositor(QWaylandCompositor *qt_compositor);
-    ~Compositor();
-
-    void init();
-
-    QWaylandInputDevice *defaultInputDevice();
-
-    void registerInputDevice(QWaylandInputDevice *device);
-    QList<QWaylandInputDevice *> inputDevices() const { return m_inputDevices; }
-    QWaylandInputDevice *inputDeviceFor(QInputEvent *inputEvent);
-    void removeInputDevice(QWaylandInputDevice *device);
-
-    void destroySurface(QWaylandSurface *surface);
-
-    void destroyClient(QWaylandClient *client);
-
-    uint currentTimeMsecs() const;
-
-    QWaylandOutput *output(QWindow *window) const;
-
-    QWaylandOutput *primaryOutput() const;
-    QWaylandOutputSpace *primaryOutputSpace() const;
-    void setPrimaryOutputSpace(QWaylandOutputSpace *outputSpace);
-    void addOutputSpace(QWaylandOutputSpace *outputSpace);
-    void removeOutputSpace(QWaylandOutputSpace *outputSpace);
-
-    ClientBufferIntegration *clientBufferIntegration() const;
-    ServerBufferIntegration *serverBufferIntegration() const;
-    void initializeHardwareIntegration();
-    void initializeExtensions();
-    void initializeDefaultInputDevice();
-    void initializeWindowManagerProtocol();
-
-    QWaylandCompositor *waylandCompositor() const { return m_qt_compositor; }
-
-    struct wl_display *wl_display() const { return m_display->handle(); }
-    Display *display() const { return m_display; }
-
-    QList<QWaylandClient *> clients() const;
-
-    QWaylandCompositor::ExtensionFlags extensions() const;
-
-    InputPanel *inputPanel() const;
-
-    DataDeviceManager *dataDeviceManager() const;
-
-    bool isDragging() const;
-    void sendDragMoveEvent(const QPoint &global, const QPoint &local, QWaylandSurface *surface);
-    void sendDragEndEvent();
-
-    void setRetainedSelectionEnabled(bool enabled);
-    bool retainedSelectionEnabled() const;
-    void overrideSelection(const QMimeData *data);
-    void feedRetainedSelectionData(QMimeData *data);
-
-    void unregisterSurface(QWaylandSurface *surface);
-
-    QWaylandPointer *callCreatePointerDevice(QWaylandInputDevice *inputDevice)
-    { return m_qt_compositor->createPointerDevice(inputDevice); }
-    QWaylandKeyboard *callCreateKeyboardDevice(QWaylandInputDevice *inputDevice)
-    { return m_qt_compositor->createKeyboardDevice(inputDevice); }
-    QWaylandTouch *callCreateTouchDevice(QWaylandInputDevice *inputDevice)
-    { return m_qt_compositor->createTouchDevice(inputDevice); }
-
-public Q_SLOTS:
-    void cleanupGraphicsResources();
-
-protected:
-    void compositor_create_surface(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
-    void compositor_create_region(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
-
-private Q_SLOTS:
-    void processWaylandEvents();
-
-protected:
-    void loadClientBufferIntegration();
-    void loadServerBufferIntegration();
-
-    QWaylandCompositor::ExtensionFlags m_extensions;
-
-    Display *m_display;
-    QByteArray m_socket_name;
-
-    /* Input */
-    QWaylandInputDevice *m_default_wayland_input_device;
-
-    QList<QWaylandInputDevice *> m_inputDevices;
-
-    /* Output */
-    QList<QWaylandOutputSpace *> m_outputSpaces;
-
-    QList<QWaylandSurface *> m_all_surfaces;
-
-    DataDeviceManager *m_data_device_manager;
-
-    QElapsedTimer m_timer;
-    QSet<QWaylandSurface *> m_destroyed_surfaces;
-
-    /* Render state */
-    uint32_t m_current_frame;
-    int m_last_queued_buf;
-
-    wl_event_loop *m_loop;
-
-    QWaylandCompositor *m_qt_compositor;
-    Qt::ScreenOrientation m_orientation;
-    QList<QWaylandClient *> m_clients;
-
-#ifdef QT_COMPOSITOR_WAYLAND_GL
-    QScopedPointer<HardwareIntegration> m_hw_integration;
-    QScopedPointer<ClientBufferIntegration> m_client_buffer_integration;
-    QScopedPointer<ServerBufferIntegration> m_server_buffer_integration;
-#endif
-
-    QScopedPointer<QWindowSystemEventHandler> m_eventHandler;
-
-    static void bind_func(struct wl_client *client, void *data,
-                          uint32_t version, uint32_t id);
-
-    bool m_retainSelection;
-    bool m_initialized;
-
-    friend class QT_PREPEND_NAMESPACE(QWaylandCompositor);
-    friend class QT_PREPEND_NAMESPACE(QWaylandClient);
-    friend class QT_PREPEND_NAMESPACE(QWaylandClientPrivate);
-};
-
-}
-
-QT_END_NAMESPACE
-
-#endif //WL_COMPOSITOR_H
diff --git a/src/compositor/wayland_wrapper/qwldatadevice.cpp b/src/compositor/wayland_wrapper/qwldatadevice.cpp
index 8dd33d3b0..a7cb3bd9c 100644
--- a/src/compositor/wayland_wrapper/qwldatadevice.cpp
+++ b/src/compositor/wayland_wrapper/qwldatadevice.cpp
@@ -36,7 +36,6 @@
 
 #include "qwldatadevice_p.h"
 
-#include "qwlcompositor_p.h"
 #include "qwldatasource_p.h"
 #include "qwldataoffer_p.h"
 #include "qwlinputdevice_p.h"
@@ -49,6 +48,7 @@
 #include "qwaylanddrag.h"
 #include "qwaylandview.h"
 #include <QtCompositor/QWaylandClient>
+#include <QtCompositor/private/qwaylandcompositor_p.h>
 
 #include <QtCore/QPointF>
 #include <QDebug>
@@ -105,7 +105,7 @@ void DataDevice::setDragFocus(QWaylandView *focus, const QPointF &localPosition)
     if (!resource)
         return;
 
-    uint32_t serial = wl_display_next_serial(m_compositor->waylandDisplay());
+    uint32_t serial = m_compositor->nextSerial();
 
     DataOffer *offer = m_dragDataSource ? new DataOffer(m_dragDataSource, resource) : 0;
 
@@ -208,7 +208,7 @@ void DataDevice::data_device_set_selection(Resource *, struct ::wl_resource *sou
         m_selectionSource->cancel();
 
     m_selectionSource = dataSource;
-    m_compositor->handle()->dataDeviceManager()->setCurrentSelectionSource(m_selectionSource);
+    QWaylandCompositorPrivate::get(m_compositor)->dataDeviceManager()->setCurrentSelectionSource(m_selectionSource);
     if (m_selectionSource)
         m_selectionSource->setDevice(this);
 
diff --git a/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp
index affc17d72..23e85813a 100644
--- a/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp
+++ b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp
@@ -36,15 +36,15 @@
 
 #include "qwldatadevicemanager_p.h"
 
+#include <QtCompositor/QWaylandCompositor>
+
+#include <QtCompositor/private/qwaylandcompositor_p.h>
 #include "qwldatadevice_p.h"
 #include "qwldatasource_p.h"
 #include "qwlinputdevice_p.h"
-#include "qwlcompositor_p.h"
 #include "qwldataoffer_p.h"
 #include "qwaylandmimehelper.h"
 
-#include <QtCompositor/private/qwaylandsurface_p.h>
-
 #include <QtCore/QDebug>
 #include <QtCore/QSocketNotifier>
 #include <fcntl.h>
@@ -55,9 +55,9 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
 
-DataDeviceManager::DataDeviceManager(Compositor *compositor)
+DataDeviceManager::DataDeviceManager(QWaylandCompositor *compositor)
     : QObject(0)
-    , wl_data_device_manager(compositor->wl_display(), 1)
+    , wl_data_device_manager(compositor->display(), 1)
     , m_compositor(compositor)
     , m_current_selection_source(0)
     , m_retainedReadNotifier(0)
@@ -105,7 +105,7 @@ void DataDeviceManager::retain()
     QList<QString> offers = m_current_selection_source->mimeTypes();
     finishReadFromClient();
     if (m_retainedReadIndex >= offers.count()) {
-        m_compositor->feedRetainedSelectionData(&m_retainedData);
+        QWaylandCompositorPrivate::get(m_compositor)->feedRetainedSelectionData(&m_retainedData);
         return;
     }
     QString mimeType = offers.at(m_retainedReadIndex);
@@ -182,7 +182,7 @@ DataSource *DataDeviceManager::currentSelectionSource()
 
 struct wl_display *DataDeviceManager::display() const
 {
-    return m_compositor->wl_display();
+    return m_compositor->display();
 }
 
 void DataDeviceManager::overrideSelection(const QMimeData &mimeData)
@@ -195,7 +195,7 @@ void DataDeviceManager::overrideSelection(const QMimeData &mimeData)
     foreach (const QString &format, formats)
         m_retainedData.setData(format, mimeData.data(format));
 
-    m_compositor->feedRetainedSelectionData(&m_retainedData);
+    QWaylandCompositorPrivate::get(m_compositor)->feedRetainedSelectionData(&m_retainedData);
 
     m_compositorOwnsSelection = true;
 
diff --git a/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h b/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h
index 5fbd45f6f..3bc50f64e 100644
--- a/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h
+++ b/src/compositor/wayland_wrapper/qwldatadevicemanager_p.h
@@ -37,13 +37,13 @@
 #ifndef WLDATADEVICEMANAGER_H
 #define WLDATADEVICEMANAGER_H
 
-#include <private/qwlcompositor_p.h>
-
 #include <QtCore/QList>
 #include <QtCore/QMap>
 #include <QtGui/QClipboard>
 #include <QtCore/QMimeData>
 
+#include <QtCompositor/QWaylandCompositor>
+
 #include <QtCompositor/private/qwayland-server-wayland.h>
 
 QT_BEGIN_NAMESPACE
@@ -52,8 +52,6 @@ class QSocketNotifier;
 
 namespace QtWayland {
 
-class Compositor;
-
 class DataDevice;
 class DataSource;
 
@@ -62,7 +60,7 @@ class DataDeviceManager : public QObject, public QtWaylandServer::wl_data_device
     Q_OBJECT
 
 public:
-    DataDeviceManager(Compositor *compositor);
+    DataDeviceManager(QWaylandCompositor *compositor);
 
     void setCurrentSelectionSource(DataSource *source);
     DataSource *currentSelectionSource();
@@ -86,7 +84,7 @@ private:
     void retain();
     void finishReadFromClient(bool exhausted = false);
 
-    Compositor *m_compositor;
+    QWaylandCompositor *m_compositor;
     QList<DataDevice *> m_data_device_list;
 
     DataSource *m_current_selection_source;
diff --git a/src/compositor/wayland_wrapper/qwldatasource.cpp b/src/compositor/wayland_wrapper/qwldatasource.cpp
index 552fda3a5..641b63b0d 100644
--- a/src/compositor/wayland_wrapper/qwldatasource.cpp
+++ b/src/compositor/wayland_wrapper/qwldatasource.cpp
@@ -38,7 +38,6 @@
 #include "qwldataoffer_p.h"
 #include "qwldatadevice_p.h"
 #include "qwldatadevicemanager_p.h"
-#include "qwlcompositor_p.h"
 
 #include <unistd.h>
 #include <QtCompositor/private/wayland-wayland-server-protocol.h>
diff --git a/src/compositor/wayland_wrapper/qwldisplay.cpp b/src/compositor/wayland_wrapper/qwldisplay.cpp
deleted file mode 100644
index 47279cca0..000000000
--- a/src/compositor/wayland_wrapper/qwldisplay.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
-**
-** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL3$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qwldisplay_p.h"
-
-#include <QtCore/QDebug>
-
-#include <QtCompositor/private/wayland-wayland-server-protocol.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace QtWayland {
-
-Display::Display()
-{
-    m_display = wl_display_create();
-
-    Q_ASSERT(m_display);
-}
-
-Display::~Display()
-{
-    wl_display_destroy(m_display);
-}
-
-}
-
-QT_END_NAMESPACE
diff --git a/src/compositor/wayland_wrapper/qwldisplay_p.h b/src/compositor/wayland_wrapper/qwldisplay_p.h
deleted file mode 100644
index 9409316ea..000000000
--- a/src/compositor/wayland_wrapper/qwldisplay_p.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
-**
-** This file is part of the QtWaylandCompositor module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL3$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef WL_DISPLAY_H
-#define WL_DISPLAY_H
-
-#include <wayland-server.h>
-#include <QtCompositor/qwaylandexport.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace QtWayland {
-
-class Display
-{
-public:
-    Display();
-    ~Display();
-
-    struct wl_display *handle() const { return m_display; }
-    struct wl_display *handle() { return m_display; }
-
-private:
-    struct wl_display *m_display;
-};
-
-}
-
-QT_END_NAMESPACE
-
-#endif //WL_DISPLAY_H
diff --git a/src/compositor/wayland_wrapper/qwlinputdevice.cpp b/src/compositor/wayland_wrapper/qwlinputdevice.cpp
index 2849a2373..12c38bf83 100644
--- a/src/compositor/wayland_wrapper/qwlinputdevice.cpp
+++ b/src/compositor/wayland_wrapper/qwlinputdevice.cpp
@@ -36,12 +36,12 @@
 
 #include "qwlinputdevice_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
+#include <QtCompositor/private/qwaylandcompositor_p.h>
 #include "qwldatadevice_p.h"
 #include "qwlinputmethod_p.h"
 #include "qwlqttouch_p.h"
 #include "qwlqtkey_p.h"
-#include "qwaylandcompositor.h"
 #include "qwaylanddrag.h"
 #include "qwlpointer_p.h"
 #include "qwlkeyboard_p.h"
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 
 QWaylandInputDevicePrivate::QWaylandInputDevicePrivate(QWaylandInputDevice *inputdevice, QWaylandCompositor *compositor)
     : QObjectPrivate()
-    , QtWaylandServer::wl_seat(compositor->waylandDisplay(), 3)
+    , QtWaylandServer::wl_seat(compositor->display(), 3)
     , m_dragHandle(new QWaylandDrag(inputdevice))
     , m_compositor(compositor)
     , m_outputSpace(compositor->primaryOutputSpace())
@@ -109,15 +109,15 @@ void QWaylandInputDevicePrivate::setCapabilities(QWaylandInputDevice::Capability
         QWaylandInputDevice::CapabilityFlags changed = caps ^ m_capabilities;
 
         if (changed & QWaylandInputDevice::Pointer) {
-            m_pointer.reset(m_pointer.isNull() ? compositor()->handle()->callCreatePointerDevice(q) : 0);
+            m_pointer.reset(m_pointer.isNull() ? QWaylandCompositorPrivate::get(compositor())->callCreatePointerDevice(q) : 0);
         }
 
         if (changed & QWaylandInputDevice::Keyboard) {
-            m_keyboard.reset(m_keyboard.isNull() ? compositor()->handle()->callCreateKeyboardDevice(q) : 0);
+            m_keyboard.reset(m_keyboard.isNull() ? QWaylandCompositorPrivate::get(compositor())->callCreateKeyboardDevice(q) : 0);
         }
 
         if (changed & QWaylandInputDevice::Touch) {
-            m_touch.reset(m_touch.isNull() ? compositor()->handle()->callCreateTouchDevice(q) : 0);
+            m_touch.reset(m_touch.isNull() ? QWaylandCompositorPrivate::get(compositor())->callCreateTouchDevice(q) : 0);
         }
 
         m_capabilities = caps;
diff --git a/src/compositor/wayland_wrapper/qwlinputmethod.cpp b/src/compositor/wayland_wrapper/qwlinputmethod.cpp
index 59f01c666..59b23cdd3 100644
--- a/src/compositor/wayland_wrapper/qwlinputmethod.cpp
+++ b/src/compositor/wayland_wrapper/qwlinputmethod.cpp
@@ -36,7 +36,7 @@
 
 #include "qwlinputmethod_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 #include "qwlinputdevice_p.h"
 #include "qwlinputmethodcontext_p.h"
 #include "qwlinputpanel_p.h"
@@ -48,7 +48,7 @@ QT_BEGIN_NAMESPACE
 namespace QtWayland {
 
 InputMethod::InputMethod(QWaylandCompositor *compositor, QWaylandInputDevice *seat)
-    : QtWaylandServer::wl_input_method(seat->compositor()->waylandDisplay(), 1)
+    : QtWaylandServer::wl_input_method(compositor->display(), 1)
     , m_compositor(compositor)
     , m_seat(seat)
     , m_resource(0)
diff --git a/src/compositor/wayland_wrapper/qwlkeyboard.cpp b/src/compositor/wayland_wrapper/qwlkeyboard.cpp
index c22b0cb26..4977ce014 100644
--- a/src/compositor/wayland_wrapper/qwlkeyboard.cpp
+++ b/src/compositor/wayland_wrapper/qwlkeyboard.cpp
@@ -37,12 +37,12 @@
 
 #include "qwlkeyboard_p.h"
 #include "qwlshellsurface_p.h"
+
 #include <QFile>
 #include <QStandardPaths>
 
 #include <QtCompositor/QWaylandClient>
-
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 
 #include <fcntl.h>
 #include <unistd.h>
@@ -115,7 +115,7 @@ void QWaylandKeyboardPrivate::focused(QWaylandSurface *surface)
     if (surface && surface->isCursorSurface())
         surface = Q_NULLPTR;
     if (m_focusResource && m_focus != surface) {
-        uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay());
+        uint32_t serial = compositor()->nextSerial();
         send_leave(m_focusResource->handle, serial, m_focus->resource());
         m_focusDestroyListener.reset();
     }
@@ -123,7 +123,7 @@ void QWaylandKeyboardPrivate::focused(QWaylandSurface *surface)
     Resource *resource = surface ? resourceMap().value(surface->waylandClient()) : 0;
 
     if (resource && (m_focus != surface || m_focusResource != resource)) {
-        uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay());
+        uint32_t serial = compositor()->nextSerial();
         send_modifiers(resource->handle, serial, m_modsDepressed, m_modsLatched, m_modsLocked, m_group);
         send_enter(resource->handle, serial, surface->resource(), QByteArray::fromRawData((char *)m_keys.data(), m_keys.size() * sizeof(uint32_t)));
         m_focusDestroyListener.listenForDestruction(surface->resource());
@@ -227,7 +227,7 @@ void QWaylandKeyboardPrivate::keyEvent(uint code, uint32_t state)
 void QWaylandKeyboardPrivate::sendKeyEvent(uint code, uint32_t state)
 {
     uint32_t time = compositor()->currentTimeMsecs();
-    uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay());
+    uint32_t serial = compositor()->nextSerial();
     uint key = code - 8;
     m_grab->key(serial, time, key, state);
 }
@@ -264,7 +264,7 @@ void QWaylandKeyboardPrivate::updateModifierState(uint code, uint32_t state)
     m_modsLocked = modsLocked;
     m_group = group;
 
-    m_grab->modifiers(wl_display_next_serial(compositor()->waylandDisplay()), m_modsDepressed, m_modsLatched, m_modsLocked, m_group);
+    m_grab->modifiers(compositor()->nextSerial(), m_modsDepressed, m_modsLatched, m_modsLocked, m_group);
 #else
     Q_UNUSED(code);
     Q_UNUSED(state);
@@ -290,7 +290,7 @@ void QWaylandKeyboardPrivate::updateKeymap()
 
     xkb_state_update_mask(m_state, 0, m_modsLatched, m_modsLocked, 0, 0, 0);
     if (m_focusResource)
-        sendKeyModifiers(m_focusResource, wl_display_next_serial(compositor()->waylandDisplay()));
+        sendKeyModifiers(m_focusResource, compositor()->nextSerial());
 #endif
 }
 
diff --git a/src/compositor/wayland_wrapper/qwloutput.cpp b/src/compositor/wayland_wrapper/qwloutput.cpp
index 82278f301..d11d91ea4 100644
--- a/src/compositor/wayland_wrapper/qwloutput.cpp
+++ b/src/compositor/wayland_wrapper/qwloutput.cpp
@@ -36,10 +36,10 @@
 ****************************************************************************/
 
 #include "qwloutput_p.h"
-#include "qwlcompositor_p.h"
 
 #include <QtGui/QWindow>
 #include <QRect>
+#include <QtCompositor/QWaylandCompositor>
 #include <QtCompositor/QWaylandSurface>
 #include <QtCompositor/QWaylandOutput>
 
@@ -101,7 +101,7 @@ static QtWaylandServer::wl_output::transform toWlTransform(const QWaylandOutput:
 }
 
 Output::Output(QWaylandOutput *output, QWaylandOutputSpace *outputSpace, QWindow *window)
-    : QtWaylandServer::wl_output(outputSpace->compositor()->waylandDisplay(), 2)
+    : QtWaylandServer::wl_output(outputSpace->compositor()->display(), 2)
     , m_window(window)
     , m_output(output)
     , m_outputSpace(Q_NULLPTR)
@@ -349,7 +349,7 @@ void Output::sendFrameCallbacks()
                 QWaylandSurfacePrivate::get(surfacemapper.surface)->sendFrameCallback();
         }
     }
-    wl_display_flush_clients(compositor()->waylandDisplay());
+    wl_display_flush_clients(compositor()->display());
 }
 
 void Output::surfaceEnter(QWaylandSurface *surface)
diff --git a/src/compositor/wayland_wrapper/qwlpointer.cpp b/src/compositor/wayland_wrapper/qwlpointer.cpp
index 9e66f4636..28a72b76e 100644
--- a/src/compositor/wayland_wrapper/qwlpointer.cpp
+++ b/src/compositor/wayland_wrapper/qwlpointer.cpp
@@ -37,7 +37,6 @@
 
 #include "qwlpointer_p.h"
 
-#include "qwlcompositor_p.h"
 #include "qwlinputdevice_p.h"
 #include "qwlkeyboard_p.h"
 #include "qwaylandcompositor.h"
@@ -125,7 +124,7 @@ void QWaylandPointerPrivate::sendMousePressEvent(Qt::MouseButton button)
     m_grab->button(time, button, WL_POINTER_BUTTON_STATE_PRESSED);
 
     if (m_buttonCount == 1) {
-        m_grabSerial = wl_display_get_serial(compositor()->waylandDisplay());
+        m_grabSerial = compositor()->nextSerial();
         q->buttonPressedChanged();
     }
 }
@@ -138,7 +137,7 @@ void QWaylandPointerPrivate::sendMouseReleaseEvent(Qt::MouseButton button)
     m_grab->button(time, button, WL_POINTER_BUTTON_STATE_RELEASED);
 
     if (m_buttonCount == 1)
-        m_grabSerial = wl_display_get_serial(compositor()->waylandDisplay());
+        m_grabSerial = compositor()->nextSerial();
     if (m_buttonCount == 0)
         q->buttonPressedChanged();
 }
diff --git a/src/compositor/wayland_wrapper/qwlregion.cpp b/src/compositor/wayland_wrapper/qwlregion.cpp
index 14a749afb..9f55980e8 100644
--- a/src/compositor/wayland_wrapper/qwlregion.cpp
+++ b/src/compositor/wayland_wrapper/qwlregion.cpp
@@ -36,8 +36,6 @@
 
 #include "qwlregion_p.h"
 
-#include "qwlcompositor_p.h"
-
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
diff --git a/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp b/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp
index 9c7671855..d65cbc567 100644
--- a/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp
+++ b/src/compositor/wayland_wrapper/qwlsurfacebuffer.cpp
@@ -36,8 +36,6 @@
 
 #include "qwlsurfacebuffer_p.h"
 
-#include "qwlcompositor_p.h"
-
 #ifdef QT_COMPOSITOR_WAYLAND_GL
 #include "hardware_integration/qwlclientbufferintegration_p.h"
 #include <qpa/qplatformopenglcontext.h>
@@ -48,6 +46,8 @@
 #include <wayland-server-protocol.h>
 #include "qwaylandshmformathelper.h"
 
+#include <QtCompositor/private/qwaylandcompositor_p.h>
+
 QT_BEGIN_NAMESPACE
 
 namespace QtWayland {
@@ -160,7 +160,7 @@ QSize SurfaceBuffer::size() const
         int height = wl_shm_buffer_get_height(shmBuffer);
         return QSize(width, height);
     }
-    if (ClientBufferIntegration *integration = m_compositor->handle()->clientBufferIntegration()) {
+    if (ClientBufferIntegration *integration = QWaylandCompositorPrivate::get(m_compositor)->clientBufferIntegration()) {
         return integration->bufferSize(m_buffer);
     }
 
@@ -173,7 +173,7 @@ QWaylandSurface::Origin SurfaceBuffer::origin() const
         return QWaylandSurface::OriginTopLeft;
     }
 
-    if (ClientBufferIntegration *integration = m_compositor->handle()->clientBufferIntegration()) {
+    if (ClientBufferIntegration *integration = QWaylandCompositorPrivate::get(m_compositor)->clientBufferIntegration()) {
         return integration->origin(m_buffer);
     }
     return QWaylandSurface::OriginTopLeft;
@@ -209,7 +209,7 @@ void SurfaceBuffer::bindToTexture() const
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width(), image.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, image.constBits());
         }
     } else {
-        if (QtWayland::ClientBufferIntegration *clientInt = m_compositor->handle()->clientBufferIntegration()) {
+        if (QtWayland::ClientBufferIntegration *clientInt = QWaylandCompositorPrivate::get(m_compositor)->clientBufferIntegration()) {
             clientInt->bindTextureToBuffer(m_buffer);
         }
     }
diff --git a/src/compositor/wayland_wrapper/qwltouch.cpp b/src/compositor/wayland_wrapper/qwltouch.cpp
index 85675a624..226f68b6a 100644
--- a/src/compositor/wayland_wrapper/qwltouch.cpp
+++ b/src/compositor/wayland_wrapper/qwltouch.cpp
@@ -37,7 +37,7 @@
 
 #include "qwltouch_p.h"
 
-#include "qwlcompositor_p.h"
+#include <QtCompositor/QWaylandCompositor>
 #include "qwaylandview.h"
 #include "qwlqttouch_p.h"
 
diff --git a/src/compositor/wayland_wrapper/wayland_wrapper.pri b/src/compositor/wayland_wrapper/wayland_wrapper.pri
index cf7194fe6..b32bf4cbb 100644
--- a/src/compositor/wayland_wrapper/wayland_wrapper.pri
+++ b/src/compositor/wayland_wrapper/wayland_wrapper.pri
@@ -5,12 +5,10 @@ WAYLANDSERVERSOURCES += \
     ../3rdparty/protocol/text.xml
 
 HEADERS += \
-    wayland_wrapper/qwlcompositor_p.h \
     wayland_wrapper/qwldatadevice_p.h \
     wayland_wrapper/qwldatadevicemanager_p.h \
     wayland_wrapper/qwldataoffer_p.h \
     wayland_wrapper/qwldatasource_p.h \
-    wayland_wrapper/qwldisplay_p.h \
     wayland_wrapper/qwlinputdevice_p.h \
     wayland_wrapper/qwlinputmethod_p.h \
     wayland_wrapper/qwlinputmethodcontext_p.h \
@@ -23,12 +21,10 @@ HEADERS += \
     ../shared/qwaylandxkb.h \
 
 SOURCES += \
-    wayland_wrapper/qwlcompositor.cpp \
     wayland_wrapper/qwldatadevice.cpp \
     wayland_wrapper/qwldatadevicemanager.cpp \
     wayland_wrapper/qwldataoffer.cpp \
     wayland_wrapper/qwldatasource.cpp \
-    wayland_wrapper/qwldisplay.cpp \
     wayland_wrapper/qwlinputdevice.cpp \
     wayland_wrapper/qwlinputmethod.cpp \
     wayland_wrapper/qwlinputmethodcontext.cpp \
diff --git a/src/hardwareintegration/compositor/drm-egl-server/drmeglserverbufferintegration.cpp b/src/hardwareintegration/compositor/drm-egl-server/drmeglserverbufferintegration.cpp
index 72130402d..520d34380 100644
--- a/src/hardwareintegration/compositor/drm-egl-server/drmeglserverbufferintegration.cpp
+++ b/src/hardwareintegration/compositor/drm-egl-server/drmeglserverbufferintegration.cpp
@@ -161,7 +161,7 @@ void DrmEglServerBufferIntegration::initializeHardware(QWaylandCompositor *compo
         return;
     }
 
-    QtWaylandServer::qt_drm_egl_server_buffer::init(compositor->waylandDisplay(), 1);
+    QtWaylandServer::qt_drm_egl_server_buffer::init(compositor->display(), 1);
 }
 
 bool DrmEglServerBufferIntegration::supportsFormat(QtWayland::ServerBuffer::Format format) const
diff --git a/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.cpp b/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.cpp
index 000e99898..93d9fb1fe 100644
--- a/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.cpp
+++ b/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.cpp
@@ -36,7 +36,7 @@
 
 #include "waylandeglclientbufferintegration.h"
 
-#include <QtCompositor/private/qwlcompositor_p.h>
+#include <QtCompositor/QWaylandCompositor>
 #include <qpa/qplatformnativeinterface.h>
 #include <QtGui/QGuiApplication>
 #include <QtGui/QOpenGLContext>
@@ -102,7 +102,7 @@ WaylandEglClientBufferIntegration::WaylandEglClientBufferIntegration()
 {
 }
 
-void WaylandEglClientBufferIntegration::initializeHardware(QtWayland::Display *waylandDisplay)
+void WaylandEglClientBufferIntegration::initializeHardware(struct wl_display *display)
 {
     Q_D(WaylandEglClientBufferIntegration);
 
@@ -153,7 +153,7 @@ void WaylandEglClientBufferIntegration::initializeHardware(QtWayland::Display *w
     }
 
     if (d->egl_bind_wayland_display && d->egl_unbind_wayland_display) {
-        d->display_bound = d->egl_bind_wayland_display(d->egl_display, waylandDisplay->handle());
+        d->display_bound = d->egl_bind_wayland_display(d->egl_display, display);
         if (!d->display_bound) {
             if (!ignoreBindDisplay) {
                 qWarning("QtCompositor: Failed to initialize EGL display. Could not bind Wayland display.");
diff --git a/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.h b/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.h
index 874d960f5..16a1fef8f 100644
--- a/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.h
+++ b/src/hardwareintegration/compositor/wayland-egl/waylandeglclientbufferintegration.h
@@ -50,7 +50,7 @@ class WaylandEglClientBufferIntegration : public QtWayland::ClientBufferIntegrat
 public:
     WaylandEglClientBufferIntegration();
 
-    void initializeHardware(QtWayland::Display *waylandDisplay) Q_DECL_OVERRIDE;
+    void initializeHardware(struct ::wl_display *display) Q_DECL_OVERRIDE;
 
     void bindTextureToBuffer(struct ::wl_resource *buffer) Q_DECL_OVERRIDE;
     QWaylandSurface::Origin origin(struct ::wl_resource *) const Q_DECL_OVERRIDE;
diff --git a/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.cpp b/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.cpp
index 0d909dcf6..5b6143db4 100644
--- a/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.cpp
+++ b/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.cpp
@@ -38,7 +38,7 @@
 
 #include "wayland-xcomposite-server-protocol.h"
 
-#include <QtCompositor/private/qwlcompositor_p.h>
+#include <QtCompositor/QWaylandCompositor>
 #include <QtGui/QGuiApplication>
 #include <qpa/qplatformnativeinterface.h>
 #include <qpa/qplatformopenglcontext.h>
@@ -70,7 +70,7 @@ XCompositeEglClientBufferIntegration::XCompositeEglClientBufferIntegration()
 
 }
 
-void XCompositeEglClientBufferIntegration::initializeHardware(QtWayland::Display *)
+void XCompositeEglClientBufferIntegration::initializeHardware(struct ::wl_display *)
 {
     QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
     if (nativeInterface) {
@@ -84,7 +84,7 @@ void XCompositeEglClientBufferIntegration::initializeHardware(QtWayland::Display
         qFatal("Platform integration doesn't have native interface");
     }
     mScreen = XDefaultScreen(mDisplay);
-    new XCompositeHandler(m_compositor->handle(), mDisplay);
+    new XCompositeHandler(m_compositor, mDisplay);
 }
 
 void XCompositeEglClientBufferIntegration::bindTextureToBuffer(struct ::wl_resource *buffer)
diff --git a/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.h b/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.h
index 27d99eb28..be493d77b 100644
--- a/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.h
+++ b/src/hardwareintegration/compositor/xcomposite-egl/xcompositeeglintegration.h
@@ -39,6 +39,8 @@
 
 #include <QtCompositor/private/qwlclientbufferintegration_p.h>
 
+#include <QtCompositor/QWaylandCompositor>
+
 #include "xlibinclude.h"
 
 #include <EGL/egl.h>
@@ -50,7 +52,7 @@ class XCompositeEglClientBufferIntegration : public QtWayland::ClientBufferInteg
 public:
     XCompositeEglClientBufferIntegration();
 
-    void initializeHardware(QtWayland::Display *waylandDisplay) Q_DECL_OVERRIDE;
+    void initializeHardware(struct ::wl_display *display) Q_DECL_OVERRIDE;
 
     void bindTextureToBuffer(struct ::wl_resource *buffer) Q_DECL_OVERRIDE;
     QWaylandSurface::Origin origin(struct ::wl_resource *) const Q_DECL_OVERRIDE;
diff --git a/src/hardwareintegration/compositor/xcomposite_share/xcompositebuffer.h b/src/hardwareintegration/compositor/xcomposite_share/xcompositebuffer.h
index e6753e185..55e953ece 100644
--- a/src/hardwareintegration/compositor/xcomposite_share/xcompositebuffer.h
+++ b/src/hardwareintegration/compositor/xcomposite_share/xcompositebuffer.h
@@ -37,9 +37,9 @@
 #ifndef XCOMPOSITEBUFFER_H
 #define XCOMPOSITEBUFFER_H
 
-#include <private/qwlcompositor_p.h>
 #include <qwayland-server-wayland.h>
 #include <QtCompositor/QWaylandSurface>
+#include <QtCompositor/QWaylandCompositor>
 
 #include <QtCore/QSize>
 
diff --git a/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.cpp b/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.cpp
index ca46207d7..b5e6a4f62 100644
--- a/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.cpp
+++ b/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.cpp
@@ -43,8 +43,8 @@
 
 QT_BEGIN_NAMESPACE
 
-XCompositeHandler::XCompositeHandler(QtWayland::Compositor *compositor, Display *display)
-    : QtWaylandServer::qt_xcomposite(compositor->wl_display(), 1)
+XCompositeHandler::XCompositeHandler(QWaylandCompositor *compositor, Display *display)
+    : QtWaylandServer::qt_xcomposite(compositor->display(), 1)
 {
     mFakeRootWindow = new QWindow();
     mFakeRootWindow->setGeometry(QRect(-1,-1,1,1));
diff --git a/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.h b/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.h
index 095a6b78d..f474b8b7e 100644
--- a/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.h
+++ b/src/hardwareintegration/compositor/xcomposite_share/xcompositehandler.h
@@ -37,7 +37,7 @@
 #ifndef XCOMPOSITEHANDLER_H
 #define XCOMPOSITEHANDLER_H
 
-#include <QtCompositor/private/qwlcompositor_p.h>
+#include <QtCompositor/QWaylandCompositor>
 
 #include "xlibinclude.h"
 
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 class XCompositeHandler : public QtWaylandServer::qt_xcomposite
 {
 public:
-    XCompositeHandler(QtWayland::Compositor *compositor, Display *display);
+    XCompositeHandler(QWaylandCompositor *compositor, Display *display);
 
 private:
     QWindow *mFakeRootWindow;
diff --git a/src/imports/compositor/qwaylandquickcompositorplugin.cpp b/src/imports/compositor/qwaylandquickcompositorplugin.cpp
index 8af03a790..d04e4940e 100644
--- a/src/imports/compositor/qwaylandquickcompositorplugin.cpp
+++ b/src/imports/compositor/qwaylandquickcompositorplugin.cpp
@@ -46,7 +46,7 @@
 #include <QtCompositor/QWaylandOutput>
 #include <QtCompositor/QWaylandOutputSpace>
 
-#include <QtCompositor/private/qwlcompositor_p.h>
+#include <QtCompositor/QWaylandCompositor>
 
 #include <QtCompositor/qwaylandexport.h>
 #include "qwaylandmousetracker_p.h"