Rename files and classes to Qt Project standard

Change-Id: Ie694227780bc0c8cdd9398e45e2e0a5d73c8a7d4
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>

25 files changed, 318 insertions, 318 deletions

diff --git a/src/plugins/platforms/mirclient/mirclient.pro b/src/plugins/platforms/mirclient/mirclient.pro
index c456f34c39..033ce579b9 100644
--- a/src/plugins/platforms/mirclient/mirclient.pro
+++ b/src/plugins/platforms/mirclient/mirclient.pro
@@ -19,29 +19,29 @@ CONFIG += link_pkgconfig
 PKGCONFIG += egl mirclient ubuntu-platform-api
 
 SOURCES = \
-    backingstore.cpp \
-    clipboard.cpp \
-    glcontext.cpp \
-    input.cpp \
-    integration.cpp \
-    nativeinterface.cpp \
-    platformservices.cpp \
-    plugin.cpp \
-    screen.cpp \
-    theme.cpp \
-    window.cpp
+    qmirclientbackingstore.cpp \
+    qmirclientclipboard.cpp \
+    qmirclientglcontext.cpp \
+    qmirclientinput.cpp \
+    qmirclientintegration.cpp \
+    qmirclientnativeinterface.cpp \
+    qmirclientplatformservices.cpp \
+    qmirclientplugin.cpp \
+    qmirclientscreen.cpp \
+    qmirclienttheme.cpp \
+    qmirclientwindow.cpp
 
 HEADERS = \
-    backingstore.h \
-    clipboard.h \
-    glcontext.h \
-    input.h \
-    integration.h \
-    logging.h \
-    nativeinterface.h \
-    orientationchangeevent_p.h \
-    platformservices.h \
-    plugin.h \
-    screen.h \
-    theme.h \
-    window.h
+    qmirclientbackingstore.h \
+    qmirclientclipboard.h \
+    qmirclientglcontext.h \
+    qmirclientinput.h \
+    qmirclientintegration.h \
+    qmirclientlogging.h \
+    qmirclientnativeinterface.h \
+    qmirclientorientationchangeevent_p.h \
+    qmirclientplatformservices.h \
+    qmirclientplugin.h \
+    qmirclientscreen.h \
+    qmirclienttheme.h \
+    qmirclientwindow.h
diff --git a/src/plugins/platforms/mirclient/backingstore.cpp b/src/plugins/platforms/mirclient/qmirclientbackingstore.cpp
index 0efde3a2f7..afd7eea936 100644
--- a/src/plugins/platforms/mirclient/backingstore.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientbackingstore.cpp
@@ -14,15 +14,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "backingstore.h"
-#include "logging.h"
+#include "qmirclientbackingstore.h"
+#include "qmirclientlogging.h"
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QOpenGLTexture>
 #include <QtGui/QMatrix4x4>
 #include <QtGui/private/qopengltextureblitter_p.h>
 #include <QtGui/qopenglfunctions.h>
 
-UbuntuBackingStore::UbuntuBackingStore(QWindow* window)
+QMirClientBackingStore::QMirClientBackingStore(QWindow* window)
     : QPlatformBackingStore(window)
     , mContext(new QOpenGLContext)
     , mTexture(new QOpenGLTexture(QOpenGLTexture::Target2D))
@@ -35,11 +35,11 @@ UbuntuBackingStore::UbuntuBackingStore(QWindow* window)
     window->setSurfaceType(QSurface::OpenGLSurface);
 }
 
-UbuntuBackingStore::~UbuntuBackingStore()
+QMirClientBackingStore::~QMirClientBackingStore()
 {
 }
 
-void UbuntuBackingStore::flush(QWindow* window, const QRegion& region, const QPoint& offset)
+void QMirClientBackingStore::flush(QWindow* window, const QRegion& region, const QPoint& offset)
 {
     Q_UNUSED(region);
     Q_UNUSED(offset);
@@ -59,7 +59,7 @@ void UbuntuBackingStore::flush(QWindow* window, const QRegion& region, const QPo
     mContext->swapBuffers(window);
 }
 
-void UbuntuBackingStore::updateTexture()
+void QMirClientBackingStore::updateTexture()
 {
     if (mDirty.isNull())
         return;
@@ -108,12 +108,12 @@ void UbuntuBackingStore::updateTexture()
 }
 
 
-void UbuntuBackingStore::beginPaint(const QRegion& region)
+void QMirClientBackingStore::beginPaint(const QRegion& region)
 {
     mDirty |= region;
 }
 
-void UbuntuBackingStore::resize(const QSize& size, const QRegion& /*staticContents*/)
+void QMirClientBackingStore::resize(const QSize& size, const QRegion& /*staticContents*/)
 {
     mImage = QImage(size, QImage::Format_RGB32);
 
@@ -121,7 +121,7 @@ void UbuntuBackingStore::resize(const QSize& size, const QRegion& /*staticConten
         mTexture->destroy();
 }
 
-QPaintDevice* UbuntuBackingStore::paintDevice()
+QPaintDevice* QMirClientBackingStore::paintDevice()
 {
     return &mImage;
 }
diff --git a/src/plugins/platforms/mirclient/backingstore.h b/src/plugins/platforms/mirclient/qmirclientbackingstore.h
index 5774f13fd8..a2fe1da01e 100644
--- a/src/plugins/platforms/mirclient/backingstore.h
+++ b/src/plugins/platforms/mirclient/qmirclientbackingstore.h
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_BACKING_STORE_H
-#define UBUNTU_BACKING_STORE_H
+#ifndef QMIRCLIENTBACKINGSTORE_H
+#define QMIRCLIENTBACKINGSTORE_H
 
 #include <qpa/qplatformbackingstore.h>
 
@@ -23,11 +23,11 @@ class QOpenGLContext;
 class QOpenGLTexture;
 class QOpenGLTextureBlitter;
 
-class UbuntuBackingStore : public QPlatformBackingStore
+class QMirClientBackingStore : public QPlatformBackingStore
 {
 public:
-    UbuntuBackingStore(QWindow* window);
-    virtual ~UbuntuBackingStore();
+    QMirClientBackingStore(QWindow* window);
+    virtual ~QMirClientBackingStore();
 
     // QPlatformBackingStore methods.
     void beginPaint(const QRegion&) override;
@@ -46,4 +46,4 @@ private:
     QRegion mDirty;
 };
 
-#endif // UBUNTU_BACKING_STORE_H
+#endif // QMIRCLIENTBACKINGSTORE_H
diff --git a/src/plugins/platforms/mirclient/clipboard.cpp b/src/plugins/platforms/mirclient/qmirclientclipboard.cpp
index 7eaca4a5a4..0e1af16dc1 100644
--- a/src/plugins/platforms/mirclient/clipboard.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientclipboard.cpp
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "clipboard.h"
+#include "qmirclientclipboard.h"
 
 #include <QtCore/QMimeData>
 #include <QtCore/QStringList>
@@ -44,7 +44,7 @@ const int maxBufferSize = 4 * 1024 * 1024;  // 4 Mb
 
 }
 
-UbuntuClipboard::UbuntuClipboard()
+QMirClientClipboard::QMirClientClipboard()
     : mMimeData(new QMimeData)
     , mIsOutdated(true)
     , mUpdatesDisabled(false)
@@ -52,12 +52,12 @@ UbuntuClipboard::UbuntuClipboard()
 {
 }
 
-UbuntuClipboard::~UbuntuClipboard()
+QMirClientClipboard::~QMirClientClipboard()
 {
     delete mMimeData;
 }
 
-void UbuntuClipboard::requestDBusClipboardContents()
+void QMirClientClipboard::requestDBusClipboardContents()
 {
     if (!mDBusSetupDone) {
         setupDBus();
@@ -74,13 +74,13 @@ void UbuntuClipboard::requestDBusClipboardContents()
                      this, SLOT(onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher*)));
 }
 
-void UbuntuClipboard::onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher* call)
+void QMirClientClipboard::onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher* call)
 {
     Q_ASSERT(call == mPendingGetContentsCall.data());
 
     QDBusPendingReply<QByteArray> reply = *call;
     if (reply.isError()) {
-        qCritical("UbuntuClipboard - Failed to get system clipboard contents via D-Bus. %s, %s",
+        qCritical("QMirClientClipboard - Failed to get system clipboard contents via D-Bus. %s, %s",
                 qPrintable(reply.error().name()), qPrintable(reply.error().message()));
         // TODO: Might try again later a number of times...
     } else {
@@ -90,18 +90,18 @@ void UbuntuClipboard::onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher
     call->deleteLater();
 }
 
-void UbuntuClipboard::onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher *call)
+void QMirClientClipboard::onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher *call)
 {
     QDBusPendingReply<void> reply = *call;
     if (reply.isError()) {
-        qCritical("UbuntuClipboard - Failed to set the system clipboard contents via D-Bus. %s, %s",
+        qCritical("QMirClientClipboard - Failed to set the system clipboard contents via D-Bus. %s, %s",
                 qPrintable(reply.error().name()), qPrintable(reply.error().message()));
         // TODO: Might try again later a number of times...
     }
     call->deleteLater();
 }
 
-void UbuntuClipboard::updateMimeData(const QByteArray &serializedMimeData)
+void QMirClientClipboard::updateMimeData(const QByteArray &serializedMimeData)
 {
     if (mUpdatesDisabled)
         return;
@@ -113,11 +113,11 @@ void UbuntuClipboard::updateMimeData(const QByteArray &serializedMimeData)
         mIsOutdated = false;
         emitChanged(QClipboard::Clipboard);
     } else {
-        qWarning("UbuntuClipboard - Got invalid serialized mime data. Ignoring it.");
+        qWarning("QMirClientClipboard - Got invalid serialized mime data. Ignoring it.");
     }
 }
 
-void UbuntuClipboard::setupDBus()
+void QMirClientClipboard::setupDBus()
 {
     QDBusConnection dbusConnection = QDBusConnection::sessionBus();
 
@@ -128,7 +128,7 @@ void UbuntuClipboard::setupDBus()
             "ContentsChanged",
             this, SLOT(updateMimeData(QByteArray)));
     if (!ok) {
-        qCritical("UbuntuClipboard - Failed to connect to ContentsChanged signal form the D-Bus system clipboard.");
+        qCritical("QMirClientClipboard - Failed to connect to ContentsChanged signal form the D-Bus system clipboard.");
     }
 
     mDBusClipboard = new QDBusInterface("com.canonical.QtMir",
@@ -139,7 +139,7 @@ void UbuntuClipboard::setupDBus()
     mDBusSetupDone = true;
 }
 
-QByteArray UbuntuClipboard::serializeMimeData(QMimeData *mimeData) const
+QByteArray QMirClientClipboard::serializeMimeData(QMimeData *mimeData) const
 {
     const QStringList formats = mimeData->formats();
     const int formatCount = qMin(formats.size(), maxFormatsCount);
@@ -173,14 +173,14 @@ QByteArray UbuntuClipboard::serializeMimeData(QMimeData *mimeData) const
             }
         }
     } else {
-        qWarning("UbuntuClipboard: Not sending contents (%d bytes) to the global clipboard as it's"
+        qWarning("QMirClientClipboard: Not sending contents (%d bytes) to the global clipboard as it's"
                 " bigger than the maximum allowed size of %d bytes", bufferSize, maxBufferSize);
     }
 
     return serializedMimeData;
 }
 
-QMimeData *UbuntuClipboard::deserializeMimeData(const QByteArray &serializedMimeData) const
+QMimeData *QMirClientClipboard::deserializeMimeData(const QByteArray &serializedMimeData) const
 {
     if (static_cast<std::size_t>(serializedMimeData.size()) < sizeof(int)) {
         // Data is invalid
@@ -213,7 +213,7 @@ QMimeData *UbuntuClipboard::deserializeMimeData(const QByteArray &serializedMime
     return mimeData;
 }
 
-QMimeData* UbuntuClipboard::mimeData(QClipboard::Mode mode)
+QMimeData* QMirClientClipboard::mimeData(QClipboard::Mode mode)
 {
     if (mode != QClipboard::Clipboard)
         return nullptr;
@@ -230,7 +230,7 @@ QMimeData* UbuntuClipboard::mimeData(QClipboard::Mode mode)
     return mMimeData;
 }
 
-void UbuntuClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
+void QMirClientClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
 {
     if (mode != QClipboard::Clipboard)
         return;
@@ -253,18 +253,18 @@ void UbuntuClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
     emitChanged(QClipboard::Clipboard);
 }
 
-bool UbuntuClipboard::supportsMode(QClipboard::Mode mode) const
+bool QMirClientClipboard::supportsMode(QClipboard::Mode mode) const
 {
     return mode == QClipboard::Clipboard;
 }
 
-bool UbuntuClipboard::ownsMode(QClipboard::Mode mode) const
+bool QMirClientClipboard::ownsMode(QClipboard::Mode mode) const
 {
     Q_UNUSED(mode);
     return false;
 }
 
-void UbuntuClipboard::setDBusClipboardContents(const QByteArray &clipboardContents)
+void QMirClientClipboard::setDBusClipboardContents(const QByteArray &clipboardContents)
 {
     if (!mPendingSetContentsCall.isNull()) {
         // Ignore any previous set call as we are going to overwrite it anyway
diff --git a/src/plugins/platforms/mirclient/clipboard.h b/src/plugins/platforms/mirclient/qmirclientclipboard.h
index f676ade9a9..d0b195bb08 100644
--- a/src/plugins/platforms/mirclient/clipboard.h
+++ b/src/plugins/platforms/mirclient/qmirclientclipboard.h
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_CLIPBOARD_H
-#define UBUNTU_CLIPBOARD_H
+#ifndef QMIRCLIENTCLIPBOARD_H
+#define QMIRCLIENTCLIPBOARD_H
 
 #include <qpa/qplatformclipboard.h>
 
@@ -24,12 +24,12 @@
 class QDBusInterface;
 class QDBusPendingCallWatcher;
 
-class UbuntuClipboard : public QObject, public QPlatformClipboard
+class QMirClientClipboard : public QObject, public QPlatformClipboard
 {
     Q_OBJECT
 public:
-    UbuntuClipboard();
-    virtual ~UbuntuClipboard();
+    QMirClientClipboard();
+    virtual ~QMirClientClipboard();
 
     // QPlatformClipboard methods.
     QMimeData* mimeData(QClipboard::Mode mode = QClipboard::Clipboard) override;
@@ -64,4 +64,4 @@ private:
     bool mDBusSetupDone;
 };
 
-#endif // UBUNTU_CLIPBOARD_H
+#endif // QMIRCLIENTCLIPBOARD_H
diff --git a/src/plugins/platforms/mirclient/glcontext.cpp b/src/plugins/platforms/mirclient/qmirclientglcontext.cpp
index ce1ecf0074..79fe1f8a33 100644
--- a/src/plugins/platforms/mirclient/glcontext.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientglcontext.cpp
@@ -14,9 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "glcontext.h"
-#include "window.h"
-#include "logging.h"
+#include "qmirclientglcontext.h"
+#include "qmirclientwindow.h"
+#include "qmirclientlogging.h"
 #include <QtPlatformSupport/private/qeglconvenience_p.h>
 
 #if !defined(QT_NO_DEBUG)
@@ -47,7 +47,7 @@ static EGLenum api_in_use()
 #endif
 }
 
-UbuntuOpenGLContext::UbuntuOpenGLContext(UbuntuScreen* screen, UbuntuOpenGLContext* share)
+QMirClientOpenGLContext::QMirClientOpenGLContext(QMirClientScreen* screen, QMirClientOpenGLContext* share)
 {
     ASSERT(screen != NULL);
     mEglDisplay = screen->eglDisplay();
@@ -65,15 +65,15 @@ UbuntuOpenGLContext::UbuntuOpenGLContext(UbuntuScreen* screen, UbuntuOpenGLConte
     DASSERT(mEglContext != EGL_NO_CONTEXT);
 }
 
-UbuntuOpenGLContext::~UbuntuOpenGLContext()
+QMirClientOpenGLContext::~QMirClientOpenGLContext()
 {
     ASSERT(eglDestroyContext(mEglDisplay, mEglContext) == EGL_TRUE);
 }
 
-bool UbuntuOpenGLContext::makeCurrent(QPlatformSurface* surface)
+bool QMirClientOpenGLContext::makeCurrent(QPlatformSurface* surface)
 {
     DASSERT(surface->surface()->surfaceType() == QSurface::OpenGLSurface);
-    EGLSurface eglSurface = static_cast<UbuntuWindow*>(surface)->eglSurface();
+    EGLSurface eglSurface = static_cast<QMirClientWindow*>(surface)->eglSurface();
 #if defined(QT_NO_DEBUG)
     eglBindAPI(api_in_use());
     eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
@@ -85,7 +85,7 @@ bool UbuntuOpenGLContext::makeCurrent(QPlatformSurface* surface)
     return true;
 }
 
-void UbuntuOpenGLContext::doneCurrent()
+void QMirClientOpenGLContext::doneCurrent()
 {
 #if defined(QT_NO_DEBUG)
     eglBindAPI(api_in_use());
@@ -96,9 +96,9 @@ void UbuntuOpenGLContext::doneCurrent()
 #endif
 }
 
-void UbuntuOpenGLContext::swapBuffers(QPlatformSurface* surface)
+void QMirClientOpenGLContext::swapBuffers(QPlatformSurface* surface)
 {
-    UbuntuWindow *ubuntuWindow = static_cast<UbuntuWindow*>(surface);
+    QMirClientWindow *ubuntuWindow = static_cast<QMirClientWindow*>(surface);
 
     EGLSurface eglSurface = ubuntuWindow->eglSurface();
 #if defined(QT_NO_DEBUG)
@@ -124,7 +124,7 @@ void UbuntuOpenGLContext::swapBuffers(QPlatformSurface* surface)
     ubuntuWindow->onBuffersSwapped_threadSafe(newBufferWidth, newBufferHeight);
 }
 
-void (*UbuntuOpenGLContext::getProcAddress(const QByteArray& procName)) ()
+void (*QMirClientOpenGLContext::getProcAddress(const QByteArray& procName)) ()
 {
 #if defined(QT_NO_DEBUG)
     eglBindAPI(api_in_use());
diff --git a/src/plugins/platforms/mirclient/glcontext.h b/src/plugins/platforms/mirclient/qmirclientglcontext.h
index 4ad8c1cde7..9305f48632 100644
--- a/src/plugins/platforms/mirclient/glcontext.h
+++ b/src/plugins/platforms/mirclient/qmirclientglcontext.h
@@ -14,17 +14,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_OPENGL_CONTEXT_H
-#define UBUNTU_OPENGL_CONTEXT_H
+#ifndef QMIRCLIENTGLCONTEXT_H
+#define QMIRCLIENTGLCONTEXT_H
 
 #include <qpa/qplatformopenglcontext.h>
-#include "screen.h"
+#include "qmirclientscreen.h"
 
-class UbuntuOpenGLContext : public QPlatformOpenGLContext
+class QMirClientOpenGLContext : public QPlatformOpenGLContext
 {
 public:
-    UbuntuOpenGLContext(UbuntuScreen* screen, UbuntuOpenGLContext* share);
-    virtual ~UbuntuOpenGLContext();
+    QMirClientOpenGLContext(QMirClientScreen* screen, QMirClientOpenGLContext* share);
+    virtual ~QMirClientOpenGLContext();
 
     // QPlatformOpenGLContext methods.
     QSurfaceFormat format() const override { return mScreen->surfaceFormat(); }
@@ -37,9 +37,9 @@ public:
     EGLContext eglContext() const { return mEglContext; }
 
 private:
-    UbuntuScreen* mScreen;
+    QMirClientScreen* mScreen;
     EGLContext mEglContext;
     EGLDisplay mEglDisplay;
 };
 
-#endif // UBUNTU_OPENGL_CONTEXT_H
+#endif // QMIRCLIENTGLCONTEXT_H
diff --git a/src/plugins/platforms/mirclient/input.cpp b/src/plugins/platforms/mirclient/qmirclientinput.cpp
index badbd1943c..62028651dc 100644
--- a/src/plugins/platforms/mirclient/input.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientinput.cpp
@@ -15,13 +15,13 @@
  */
 
 // Local
-#include "input.h"
-#include "integration.h"
-#include "nativeinterface.h"
-#include "screen.h"
-#include "window.h"
-#include "logging.h"
-#include "orientationchangeevent_p.h"
+#include "qmirclientinput.h"
+#include "qmirclientintegration.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientwindow.h"
+#include "qmirclientlogging.h"
+#include "qmirclientorientationchangeevent_p.h"
 
 // Qt
 #if !defined(QT_NO_DEBUG)
@@ -120,26 +120,26 @@ static const uint32_t KeyTable[] = {
     0,                          0
 };
 
-class UbuntuEvent : public QEvent
+class QMirClientEvent : public QEvent
 {
 public:
-    UbuntuEvent(UbuntuWindow* window, const MirEvent *event, QEvent::Type type)
+    QMirClientEvent(QMirClientWindow* window, const MirEvent *event, QEvent::Type type)
         : QEvent(type), window(window) {
         nativeEvent = mir_event_ref(event);
     }
-    ~UbuntuEvent()
+    ~QMirClientEvent()
     {
         mir_event_unref(nativeEvent);
     }
 
-    QPointer<UbuntuWindow> window;
+    QPointer<QMirClientWindow> window;
     const MirEvent *nativeEvent;
 };
 
-UbuntuInput::UbuntuInput(UbuntuClientIntegration* integration)
+QMirClientInput::QMirClientInput(QMirClientClientIntegration* integration)
     : QObject(nullptr)
     , mIntegration(integration)
-    , mEventFilterType(static_cast<UbuntuNativeInterface*>(
+    , mEventFilterType(static_cast<QMirClientNativeInterface*>(
         integration->nativeInterface())->genericEventFilterType())
     , mEventType(static_cast<QEvent::Type>(QEvent::registerEventType()))
 {
@@ -152,7 +152,7 @@ UbuntuInput::UbuntuInput(UbuntuClientIntegration* integration)
     QWindowSystemInterface::registerTouchDevice(mTouchDevice);
 }
 
-UbuntuInput::~UbuntuInput()
+QMirClientInput::~QMirClientInput()
 {
   // Qt will take care of deleting mTouchDevice.
 }
@@ -185,10 +185,10 @@ static const char* nativeEventTypeToStr(MirEventType t)
 }
 #endif // LOG_EVENTS != 0
 
-void UbuntuInput::customEvent(QEvent* event)
+void QMirClientInput::customEvent(QEvent* event)
 {
     DASSERT(QThread::currentThread() == thread());
-    UbuntuEvent* ubuntuEvent = static_cast<UbuntuEvent*>(event);
+    QMirClientEvent* ubuntuEvent = static_cast<QMirClientEvent*>(event);
     const MirEvent *nativeEvent = ubuntuEvent->nativeEvent;
 
     if ((ubuntuEvent->window == nullptr) || (ubuntuEvent->window->window() == nullptr)) {
@@ -206,7 +206,7 @@ void UbuntuInput::customEvent(QEvent* event)
     }
 
     #if (LOG_EVENTS != 0)
-    LOG("UbuntuInput::customEvent(type=%s)", nativeEventTypeToStr(mir_event_get_type(nativeEvent)));
+    LOG("QMirClientInput::customEvent(type=%s)", nativeEventTypeToStr(mir_event_get_type(nativeEvent)));
     #endif
 
     // Event dispatching.
@@ -249,21 +249,21 @@ void UbuntuInput::customEvent(QEvent* event)
     }
 }
 
-void UbuntuInput::postEvent(UbuntuWindow *platformWindow, const MirEvent *event)
+void QMirClientInput::postEvent(QMirClientWindow *platformWindow, const MirEvent *event)
 {
     QWindow *window = platformWindow->window();
 
-    QCoreApplication::postEvent(this, new UbuntuEvent(
+    QCoreApplication::postEvent(this, new QMirClientEvent(
             platformWindow, event, mEventType));
 
     if ((window->flags().testFlag(Qt::WindowTransparentForInput)) && window->parent()) {
-        QCoreApplication::postEvent(this, new UbuntuEvent(
-                    static_cast<UbuntuWindow*>(platformWindow->QPlatformWindow::parent()),
+        QCoreApplication::postEvent(this, new QMirClientEvent(
+                    static_cast<QMirClientWindow*>(platformWindow->QPlatformWindow::parent()),
                     event, mEventType));
     }
 }
 
-void UbuntuInput::dispatchInputEvent(QWindow *window, const MirInputEvent *ev)
+void QMirClientInput::dispatchInputEvent(QWindow *window, const MirInputEvent *ev)
 {
     switch (mir_input_event_get_type(ev))
     {
@@ -281,7 +281,7 @@ void UbuntuInput::dispatchInputEvent(QWindow *window, const MirInputEvent *ev)
     }
 }
 
-void UbuntuInput::dispatchTouchEvent(QWindow *window, const MirInputEvent *ev)
+void QMirClientInput::dispatchTouchEvent(QWindow *window, const MirInputEvent *ev)
 {
     const MirTouchEvent *tev = mir_input_event_get_touch_event(ev);
 
@@ -369,7 +369,7 @@ Qt::KeyboardModifiers qt_modifiers_from_mir(MirInputEventModifiers modifiers)
 }
 }
 
-void UbuntuInput::dispatchKeyEvent(QWindow *window, const MirInputEvent *event)
+void QMirClientInput::dispatchKeyEvent(QWindow *window, const MirInputEvent *event)
 {
     const MirKeyboardEvent *key_event = mir_input_event_get_keyboard_event(event);
 
@@ -420,7 +420,7 @@ Qt::MouseButtons extract_buttons(const MirPointerEvent *pev)
 }
 }
 
-void UbuntuInput::dispatchPointerEvent(QWindow *window, const MirInputEvent *ev)
+void QMirClientInput::dispatchPointerEvent(QWindow *window, const MirInputEvent *ev)
 {
     auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
 
@@ -457,7 +457,7 @@ static const char* nativeOrientationDirectionToStr(MirOrientation orientation)
 }
 #endif
 
-void UbuntuInput::dispatchOrientationEvent(QWindow *window, const MirOrientationEvent *event)
+void QMirClientInput::dispatchOrientationEvent(QWindow *window, const MirOrientationEvent *event)
 {
     MirOrientation mir_orientation = mir_orientation_event_get_direction(event);
     #if (LOG_EVENTS != 0)
@@ -493,7 +493,7 @@ void UbuntuInput::dispatchOrientationEvent(QWindow *window, const MirOrientation
     // notifying Qt of the actual orientation change - done to prevent multiple Windows each creating
     // an identical orientation change event and passing it directly to Qt.
     // [Platform]Screen can also factor in the native orientation.
-    QCoreApplication::postEvent(static_cast<UbuntuScreen*>(window->screen()->handle()),
+    QCoreApplication::postEvent(static_cast<QMirClientScreen*>(window->screen()->handle()),
                                 new OrientationChangeEvent(OrientationChangeEvent::mType, orientation));
 }
 
diff --git a/src/plugins/platforms/mirclient/input.h b/src/plugins/platforms/mirclient/qmirclientinput.h
index 6c7aa97fe2..d752ca64ff 100644
--- a/src/plugins/platforms/mirclient/input.h
+++ b/src/plugins/platforms/mirclient/qmirclientinput.h
@@ -14,30 +14,30 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_INPUT_H
-#define UBUNTU_INPUT_H
+#ifndef QMIRCLIENTINPUT_H
+#define QMIRCLIENTINPUT_H
 
 // Qt
 #include <qpa/qwindowsysteminterface.h>
 
 #include <mir_toolkit/mir_client_library.h>
 
-class UbuntuClientIntegration;
-class UbuntuWindow;
+class QMirClientClientIntegration;
+class QMirClientWindow;
 
-class UbuntuInput : public QObject
+class QMirClientInput : public QObject
 {
     Q_OBJECT
 
 public:
-    UbuntuInput(UbuntuClientIntegration* integration);
-    virtual ~UbuntuInput();
+    QMirClientInput(QMirClientClientIntegration* integration);
+    virtual ~QMirClientInput();
 
     // QObject methods.
     void customEvent(QEvent* event) override;
 
-    void postEvent(UbuntuWindow* window, const MirEvent *event);
-    UbuntuClientIntegration* integration() const { return mIntegration; }
+    void postEvent(QMirClientWindow* window, const MirEvent *event);
+    QMirClientClientIntegration* integration() const { return mIntegration; }
 
 protected:
     void dispatchKeyEvent(QWindow *window, const MirInputEvent *event);
@@ -48,10 +48,10 @@ protected:
     void dispatchOrientationEvent(QWindow* window, const MirOrientationEvent *event);
 
 private:
-    UbuntuClientIntegration* mIntegration;
+    QMirClientClientIntegration* mIntegration;
     QTouchDevice* mTouchDevice;
     const QByteArray mEventFilterType;
     const QEvent::Type mEventType;
 };
 
-#endif // UBUNTU_INPUT_H
+#endif // QMIRCLIENTINPUT_H
diff --git a/src/plugins/platforms/mirclient/integration.cpp b/src/plugins/platforms/mirclient/qmirclientintegration.cpp
index 6dc04c4507..269d390f56 100644
--- a/src/plugins/platforms/mirclient/integration.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientintegration.cpp
@@ -25,16 +25,16 @@
 #include <QOpenGLContext>
 
 // Local
-#include "backingstore.h"
-#include "clipboard.h"
-#include "glcontext.h"
-#include "input.h"
-#include "integration.h"
-#include "logging.h"
-#include "nativeinterface.h"
-#include "screen.h"
-#include "theme.h"
-#include "window.h"
+#include "qmirclientbackingstore.h"
+#include "qmirclientclipboard.h"
+#include "qmirclientglcontext.h"
+#include "qmirclientinput.h"
+#include "qmirclientintegration.h"
+#include "qmirclientlogging.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclienttheme.h"
+#include "qmirclientwindow.h"
 
 // platform-api
 #include <ubuntu/application/lifecycle_delegate.h>
@@ -54,18 +54,18 @@ static void aboutToStopCallback(UApplicationArchive *archive, void* context)
 {
     Q_UNUSED(archive)
     DASSERT(context != NULL);
-    UbuntuClientIntegration* integration = static_cast<UbuntuClientIntegration*>(context);
+    QMirClientClientIntegration* integration = static_cast<QMirClientClientIntegration*>(context);
     integration->inputContext()->hideInputPanel();
     QCoreApplication::postEvent(QCoreApplication::instance(),
                                 new QEvent(QEvent::ApplicationDeactivate));
 }
 
-UbuntuClientIntegration::UbuntuClientIntegration()
+QMirClientClientIntegration::QMirClientClientIntegration()
     : QPlatformIntegration()
-    , mNativeInterface(new UbuntuNativeInterface)
+    , mNativeInterface(new QMirClientNativeInterface)
     , mFontDb(new QGenericUnixFontDatabase)
-    , mServices(new UbuntuPlatformServices)
-    , mClipboard(new UbuntuClipboard)
+    , mServices(new QMirClientPlatformServices)
+    , mClipboard(new QMirClientClipboard)
     , mScaleFactor(1.0)
 {
     setupOptions();
@@ -75,17 +75,17 @@ UbuntuClientIntegration::UbuntuClientIntegration()
     mInstance = u_application_instance_new_from_description_with_options(mDesc, mOptions);
 
     if (mInstance == nullptr)
-        qFatal("UbuntuClientIntegration: connection to Mir server failed. Check that a Mir server is\n"
+        qFatal("QMirClientClientIntegration: connection to Mir server failed. Check that a Mir server is\n"
                "running, and the correct socket is being used and is accessible. The shell may have\n"
                "rejected the incoming connection, so check its log file");
 
     // Create default screen.
-    mScreen = new UbuntuScreen(u_application_instance_get_mir_connection(mInstance));
+    mScreen = new QMirClientScreen(u_application_instance_get_mir_connection(mInstance));
     screenAdded(mScreen);
 
     // Initialize input.
     if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_INPUT")) {
-        mInput = new UbuntuInput(this);
+        mInput = new QMirClientInput(this);
         mInputContext = QPlatformInputContextFactory::create();
     } else {
         mInput = nullptr;
@@ -106,7 +106,7 @@ UbuntuClientIntegration::UbuntuClientIntegration()
     mScaleFactor = static_cast<qreal>(gridUnit) / defaultGridUnit;
 }
 
-UbuntuClientIntegration::~UbuntuClientIntegration()
+QMirClientClientIntegration::~QMirClientClientIntegration()
 {
     delete mInput;
     delete mInputContext;
@@ -114,12 +114,12 @@ UbuntuClientIntegration::~UbuntuClientIntegration()
     delete mServices;
 }
 
-QPlatformServices *UbuntuClientIntegration::services() const
+QPlatformServices *QMirClientClientIntegration::services() const
 {
     return mServices;
 }
 
-void UbuntuClientIntegration::setupOptions()
+void QMirClientClientIntegration::setupOptions()
 {
     QStringList args = QCoreApplication::arguments();
     int argc = args.size() + 1;
@@ -135,7 +135,7 @@ void UbuntuClientIntegration::setupOptions()
     delete [] argv;
 }
 
-void UbuntuClientIntegration::setupDescription()
+void QMirClientClientIntegration::setupDescription()
 {
     mDesc = u_application_description_new();
     UApplicationId* id = u_application_id_new_from_stringn("QtUbuntu", 8);
@@ -148,20 +148,20 @@ void UbuntuClientIntegration::setupDescription()
     u_application_description_set_application_lifecycle_delegate(mDesc, delegate);
 }
 
-QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window) const
+QPlatformWindow* QMirClientClientIntegration::createPlatformWindow(QWindow* window) const
 {
-    return const_cast<UbuntuClientIntegration*>(this)->createPlatformWindow(window);
+    return const_cast<QMirClientClientIntegration*>(this)->createPlatformWindow(window);
 }
 
-QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window)
+QPlatformWindow* QMirClientClientIntegration::createPlatformWindow(QWindow* window)
 {
-    QPlatformWindow* platformWindow = new UbuntuWindow(
-            window, mClipboard, static_cast<UbuntuScreen*>(mScreen), mInput, u_application_instance_get_mir_connection(mInstance));
+    QPlatformWindow* platformWindow = new QMirClientWindow(
+            window, mClipboard, static_cast<QMirClientScreen*>(mScreen), mInput, u_application_instance_get_mir_connection(mInstance));
     platformWindow->requestActivateWindow();
     return platformWindow;
 }
 
-bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
+bool QMirClientClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
 {
     switch (cap) {
     case ThreadedPixmaps:
@@ -186,41 +186,41 @@ bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap
     }
 }
 
-QAbstractEventDispatcher *UbuntuClientIntegration::createEventDispatcher() const
+QAbstractEventDispatcher *QMirClientClientIntegration::createEventDispatcher() const
 {
     return createUnixEventDispatcher();
 }
 
-QPlatformBackingStore* UbuntuClientIntegration::createPlatformBackingStore(QWindow* window) const
+QPlatformBackingStore* QMirClientClientIntegration::createPlatformBackingStore(QWindow* window) const
 {
-    return new UbuntuBackingStore(window);
+    return new QMirClientBackingStore(window);
 }
 
-QPlatformOpenGLContext* UbuntuClientIntegration::createPlatformOpenGLContext(
+QPlatformOpenGLContext* QMirClientClientIntegration::createPlatformOpenGLContext(
         QOpenGLContext* context) const
 {
-    return const_cast<UbuntuClientIntegration*>(this)->createPlatformOpenGLContext(context);
+    return const_cast<QMirClientClientIntegration*>(this)->createPlatformOpenGLContext(context);
 }
 
-QPlatformOpenGLContext* UbuntuClientIntegration::createPlatformOpenGLContext(
+QPlatformOpenGLContext* QMirClientClientIntegration::createPlatformOpenGLContext(
         QOpenGLContext* context)
 {
-    return new UbuntuOpenGLContext(static_cast<UbuntuScreen*>(context->screen()->handle()),
-                                   static_cast<UbuntuOpenGLContext*>(context->shareHandle()));
+    return new QMirClientOpenGLContext(static_cast<QMirClientScreen*>(context->screen()->handle()),
+                                   static_cast<QMirClientOpenGLContext*>(context->shareHandle()));
 }
 
-QStringList UbuntuClientIntegration::themeNames() const
+QStringList QMirClientClientIntegration::themeNames() const
 {
-    return QStringList(UbuntuTheme::name);
+    return QStringList(QMirClientTheme::name);
 }
 
-QPlatformTheme* UbuntuClientIntegration::createPlatformTheme(const QString& name) const
+QPlatformTheme* QMirClientClientIntegration::createPlatformTheme(const QString& name) const
 {
     Q_UNUSED(name);
-    return new UbuntuTheme;
+    return new QMirClientTheme;
 }
 
-QVariant UbuntuClientIntegration::styleHint(StyleHint hint) const
+QVariant QMirClientClientIntegration::styleHint(StyleHint hint) const
 {
     switch (hint) {
         case QPlatformIntegration::StartDragDistance: {
@@ -237,7 +237,7 @@ QVariant UbuntuClientIntegration::styleHint(StyleHint hint) const
     return QPlatformIntegration::styleHint(hint);
 }
 
-QPlatformClipboard* UbuntuClientIntegration::clipboard() const
+QPlatformClipboard* QMirClientClientIntegration::clipboard() const
 {
     return mClipboard.data();
 }
diff --git a/src/plugins/platforms/mirclient/integration.h b/src/plugins/platforms/mirclient/qmirclientintegration.h
index 45c10ba432..0e1fc0160f 100644
--- a/src/plugins/platforms/mirclient/integration.h
+++ b/src/plugins/platforms/mirclient/qmirclientintegration.h
@@ -14,26 +14,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_CLIENT_INTEGRATION_H
-#define UBUNTU_CLIENT_INTEGRATION_H
+#ifndef QMIRCLIENTINTEGRATION_H
+#define QMIRCLIENTINTEGRATION_H
 
 #include <qpa/qplatformintegration.h>
 #include <QSharedPointer>
 
-#include "platformservices.h"
+#include "qmirclientplatformservices.h"
 
 // platform-api
 #include <ubuntu/application/description.h>
 #include <ubuntu/application/instance.h>
 
-class UbuntuClipboard;
-class UbuntuInput;
-class UbuntuScreen;
+class QMirClientClipboard;
+class QMirClientInput;
+class QMirClientScreen;
 
-class UbuntuClientIntegration : public QPlatformIntegration {
+class QMirClientClientIntegration : public QPlatformIntegration {
 public:
-    UbuntuClientIntegration();
-    virtual ~UbuntuClientIntegration();
+    QMirClientClientIntegration();
+    virtual ~QMirClientClientIntegration();
 
     // QPlatformIntegration methods.
     bool hasCapability(QPlatformIntegration::Capability cap) const override;
@@ -52,7 +52,7 @@ public:
 
     QPlatformOpenGLContext* createPlatformOpenGLContext(QOpenGLContext* context);
     QPlatformWindow* createPlatformWindow(QWindow* window);
-    UbuntuScreen* screen() const { return mScreen; }
+    QMirClientScreen* screen() const { return mScreen; }
 
 private:
     void setupOptions();
@@ -61,12 +61,12 @@ private:
     QPlatformNativeInterface* mNativeInterface;
     QPlatformFontDatabase* mFontDb;
 
-    UbuntuPlatformServices* mServices;
+    QMirClientPlatformServices* mServices;
 
-    UbuntuScreen* mScreen;
-    UbuntuInput* mInput;
+    QMirClientScreen* mScreen;
+    QMirClientInput* mInput;
     QPlatformInputContext* mInputContext;
-    QSharedPointer<UbuntuClipboard> mClipboard;
+    QSharedPointer<QMirClientClipboard> mClipboard;
     qreal mScaleFactor;
 
     // Platform API stuff
@@ -75,4 +75,4 @@ private:
     UApplicationInstance* mInstance;
 };
 
-#endif // UBUNTU_CLIENT_INTEGRATION_H
+#endif // QMIRCLIENTINTEGRATION_H
diff --git a/src/plugins/platforms/mirclient/logging.h b/src/plugins/platforms/mirclient/qmirclientlogging.h
index 07f57245d7..e413cd00f3 100644
--- a/src/plugins/platforms/mirclient/logging.h
+++ b/src/plugins/platforms/mirclient/qmirclientlogging.h
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef QUBUNTULOGGING_H
-#define QUBUNTULOGGING_H
+#ifndef QMIRCLIENTLOGGING_H
+#define QMIRCLIENTLOGGING_H
 
 // Logging and assertion macros.
 #define LOG(...) qDebug(__VA_ARGS__)
@@ -36,4 +36,4 @@
 #define DNOT_REACHED() qt_noop()
 #endif
 
-#endif  // QUBUNTULOGGING_H
+#endif  // QMIRCLIENTLOGGING_H
diff --git a/src/plugins/platforms/mirclient/nativeinterface.cpp b/src/plugins/platforms/mirclient/qmirclientnativeinterface.cpp
index cad1871cea..072b02ec4e 100644
--- a/src/plugins/platforms/mirclient/nativeinterface.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientnativeinterface.cpp
@@ -21,37 +21,37 @@
 #include <QtCore/QMap>
 
 // Local
-#include "nativeinterface.h"
-#include "screen.h"
-#include "glcontext.h"
+#include "qmirclientnativeinterface.h"
+#include "qmirclientscreen.h"
+#include "qmirclientglcontext.h"
 
-class UbuntuResourceMap : public QMap<QByteArray, UbuntuNativeInterface::ResourceType>
+class QMirClientResourceMap : public QMap<QByteArray, QMirClientNativeInterface::ResourceType>
 {
 public:
-    UbuntuResourceMap()
-        : QMap<QByteArray, UbuntuNativeInterface::ResourceType>() {
-        insert("egldisplay", UbuntuNativeInterface::EglDisplay);
-        insert("eglcontext", UbuntuNativeInterface::EglContext);
-        insert("nativeorientation", UbuntuNativeInterface::NativeOrientation);
-        insert("display", UbuntuNativeInterface::Display);
+    QMirClientResourceMap()
+        : QMap<QByteArray, QMirClientNativeInterface::ResourceType>() {
+        insert("egldisplay", QMirClientNativeInterface::EglDisplay);
+        insert("eglcontext", QMirClientNativeInterface::EglContext);
+        insert("nativeorientation", QMirClientNativeInterface::NativeOrientation);
+        insert("display", QMirClientNativeInterface::Display);
     }
 };
 
-Q_GLOBAL_STATIC(UbuntuResourceMap, ubuntuResourceMap)
+Q_GLOBAL_STATIC(QMirClientResourceMap, ubuntuResourceMap)
 
-UbuntuNativeInterface::UbuntuNativeInterface()
+QMirClientNativeInterface::QMirClientNativeInterface()
     : mGenericEventFilterType(QByteArrayLiteral("Event"))
     , mNativeOrientation(nullptr)
 {
 }
 
-UbuntuNativeInterface::~UbuntuNativeInterface()
+QMirClientNativeInterface::~QMirClientNativeInterface()
 {
     delete mNativeOrientation;
     mNativeOrientation = nullptr;
 }
 
-void* UbuntuNativeInterface::nativeResourceForContext(
+void* QMirClientNativeInterface::nativeResourceForContext(
     const QByteArray& resourceString, QOpenGLContext* context)
 {
     if (!context)
@@ -64,29 +64,29 @@ void* UbuntuNativeInterface::nativeResourceForContext(
 
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
 
-    if (kResourceType == UbuntuNativeInterface::EglContext)
-        return static_cast<UbuntuOpenGLContext*>(context->handle())->eglContext();
+    if (kResourceType == QMirClientNativeInterface::EglContext)
+        return static_cast<QMirClientOpenGLContext*>(context->handle())->eglContext();
     else
         return nullptr;
 }
 
-void* UbuntuNativeInterface::nativeResourceForWindow(const QByteArray& resourceString, QWindow* window)
+void* QMirClientNativeInterface::nativeResourceForWindow(const QByteArray& resourceString, QWindow* window)
 {
     const QByteArray kLowerCaseResource = resourceString.toLower();
     if (!ubuntuResourceMap()->contains(kLowerCaseResource))
         return NULL;
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
-    if (kResourceType == UbuntuNativeInterface::EglDisplay) {
+    if (kResourceType == QMirClientNativeInterface::EglDisplay) {
         if (window) {
-            return static_cast<UbuntuScreen*>(window->screen()->handle())->eglDisplay();
+            return static_cast<QMirClientScreen*>(window->screen()->handle())->eglDisplay();
         } else {
-            return static_cast<UbuntuScreen*>(
+            return static_cast<QMirClientScreen*>(
                     QGuiApplication::primaryScreen()->handle())->eglDisplay();
         }
-    } else if (kResourceType == UbuntuNativeInterface::NativeOrientation) {
+    } else if (kResourceType == QMirClientNativeInterface::NativeOrientation) {
         // Return the device's native screen orientation.
         if (window) {
-            UbuntuScreen *ubuntuScreen = static_cast<UbuntuScreen*>(window->screen()->handle());
+            QMirClientScreen *ubuntuScreen = static_cast<QMirClientScreen*>(window->screen()->handle());
             mNativeOrientation = new Qt::ScreenOrientation(ubuntuScreen->nativeOrientation());
         } else {
             QPlatformScreen *platformScreen = QGuiApplication::primaryScreen()->handle();
@@ -98,16 +98,16 @@ void* UbuntuNativeInterface::nativeResourceForWindow(const QByteArray& resourceS
     }
 }
 
-void* UbuntuNativeInterface::nativeResourceForScreen(const QByteArray& resourceString, QScreen* screen)
+void* QMirClientNativeInterface::nativeResourceForScreen(const QByteArray& resourceString, QScreen* screen)
 {
     const QByteArray kLowerCaseResource = resourceString.toLower();
     if (!ubuntuResourceMap()->contains(kLowerCaseResource))
         return NULL;
     const ResourceType kResourceType = ubuntuResourceMap()->value(kLowerCaseResource);
-    if (kResourceType == UbuntuNativeInterface::Display) {
+    if (kResourceType == QMirClientNativeInterface::Display) {
         if (!screen)
             screen = QGuiApplication::primaryScreen();
-        return static_cast<UbuntuScreen*>(screen->handle())->eglNativeDisplay();
+        return static_cast<QMirClientScreen*>(screen->handle())->eglNativeDisplay();
     } else
         return NULL;
 }
diff --git a/src/plugins/platforms/mirclient/nativeinterface.h b/src/plugins/platforms/mirclient/qmirclientnativeinterface.h
index 129afb1083..70b70f2eae 100644
--- a/src/plugins/platforms/mirclient/nativeinterface.h
+++ b/src/plugins/platforms/mirclient/qmirclientnativeinterface.h
@@ -14,17 +14,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_NATIVE_INTERFACE_H
-#define UBUNTU_NATIVE_INTERFACE_H
+#ifndef QMIRCLIENTNATIVEINTERFACE_H
+#define QMIRCLIENTNATIVEINTERFACE_H
 
 #include <qpa/qplatformnativeinterface.h>
 
-class UbuntuNativeInterface : public QPlatformNativeInterface {
+class QMirClientNativeInterface : public QPlatformNativeInterface {
 public:
     enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display };
 
-    UbuntuNativeInterface();
-    ~UbuntuNativeInterface();
+    QMirClientNativeInterface();
+    ~QMirClientNativeInterface();
 
     // QPlatformNativeInterface methods.
     void* nativeResourceForContext(const QByteArray& resourceString,
@@ -42,4 +42,4 @@ private:
     Qt::ScreenOrientation* mNativeOrientation;
 };
 
-#endif // UBUNTU_NATIVE_INTERFACE_H
+#endif // QMIRCLIENTNATIVEINTERFACE_H
diff --git a/src/plugins/platforms/mirclient/orientationchangeevent_p.h b/src/plugins/platforms/mirclient/qmirclientorientationchangeevent_p.h
index 1a6553155e..575f89a39c 100644
--- a/src/plugins/platforms/mirclient/orientationchangeevent_p.h
+++ b/src/plugins/platforms/mirclient/qmirclientorientationchangeevent_p.h
@@ -14,11 +14,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef ORIENTATIONCHANGEEVENT_P_H
-#define ORIENTATIONCHANGEEVENT_P_H
+#ifndef QMIRCLIENTORIENTATIONCHANGEEVENT_P_H
+#define QMIRCLIENTORIENTATIONCHANGEEVENT_P_H
 
 #include <QEvent>
-#include "logging.h"
+#include "qmirclientlogging.h"
 
 class OrientationChangeEvent : public QEvent {
 public:
@@ -42,4 +42,4 @@ public:
     Orientation mOrientation;
 };
 
-#endif // ORIENTATIONCHANGEEVENT_P_H
+#endif // QMIRCLIENTORIENTATIONCHANGEEVENT_P_H
diff --git a/src/plugins/platforms/mirclient/platformservices.cpp b/src/plugins/platforms/mirclient/qmirclientplatformservices.cpp
index c9a974b711..0c93107dc9 100644
--- a/src/plugins/platforms/mirclient/platformservices.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientplatformservices.cpp
@@ -14,24 +14,24 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "platformservices.h"
+#include "qmirclientplatformservices.h"
 
 #include <QUrl>
 
 #include <ubuntu/application/url_dispatcher/service.h>
 #include <ubuntu/application/url_dispatcher/session.h>
 
-bool UbuntuPlatformServices::openUrl(const QUrl &url)
+bool QMirClientPlatformServices::openUrl(const QUrl &url)
 {
     return callDispatcher(url);
 }
 
-bool UbuntuPlatformServices::openDocument(const QUrl &url)
+bool QMirClientPlatformServices::openDocument(const QUrl &url)
 {
     return callDispatcher(url);
 }
 
-bool UbuntuPlatformServices::callDispatcher(const QUrl &url)
+bool QMirClientPlatformServices::callDispatcher(const QUrl &url)
 {
     UAUrlDispatcherSession* session = ua_url_dispatcher_session();
     if (!session)
diff --git a/src/plugins/platforms/mirclient/platformservices.h b/src/plugins/platforms/mirclient/qmirclientplatformservices.h
index 1c3e68bf8a..3d90e28f68 100644
--- a/src/plugins/platforms/mirclient/platformservices.h
+++ b/src/plugins/platforms/mirclient/qmirclientplatformservices.h
@@ -14,14 +14,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_PLATFORM_SERVICES_H
-#define UBUNTU_PLATFORM_SERVICES_H
+#ifndef QMIRCLIENTPLATFORMSERVICES_H
+#define QMIRCLIENTPLATFORMSERVICES_H
 
 #include <qpa/qplatformservices.h>
 #include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>
 #include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>
 
-class UbuntuPlatformServices : public QPlatformServices {
+class QMirClientPlatformServices : public QPlatformServices {
 public:
     bool openUrl(const QUrl &url) override;
     bool openDocument(const QUrl &url) override;
@@ -30,4 +30,4 @@ private:
     bool callDispatcher(const QUrl &url);
 };
 
-#endif // UBUNTU_PLATFORM_SERVICES_H
+#endif // QMIRCLIENTPLATFORMSERVICES_H
diff --git a/src/plugins/platforms/mirclient/plugin.cpp b/src/plugins/platforms/mirclient/qmirclientplugin.cpp
index 2d65aaae61..e67ea7ae62 100644
--- a/src/plugins/platforms/mirclient/plugin.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientplugin.cpp
@@ -14,17 +14,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "plugin.h"
-#include "integration.h"
+#include "qmirclientplugin.h"
+#include "qmirclientintegration.h"
 
-QStringList UbuntuMirClientIntegrationPlugin::keys() const
+QStringList QMirClientIntegrationPlugin::keys() const
 {
     QStringList list;
     list << "mirclient";
     return list;
 }
 
-QPlatformIntegration* UbuntuMirClientIntegrationPlugin::create(const QString &system,
+QPlatformIntegration* QMirClientIntegrationPlugin::create(const QString &system,
                                                                const QStringList &)
 {
     if (system.toLower() == "mirclient") {
@@ -33,7 +33,7 @@ QPlatformIntegration* UbuntuMirClientIntegrationPlugin::create(const QString &sy
 #else
         setenv("UBUNTU_PLATFORM_API_BACKEND", "desktop_mirclient", 1);
 #endif
-        return new UbuntuClientIntegration;
+        return new QMirClientClientIntegration;
     } else {
         return 0;
     }
diff --git a/src/plugins/platforms/mirclient/plugin.h b/src/plugins/platforms/mirclient/qmirclientplugin.h
index 7a147bd4d1..fb29d889ae 100644
--- a/src/plugins/platforms/mirclient/plugin.h
+++ b/src/plugins/platforms/mirclient/qmirclientplugin.h
@@ -14,12 +14,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_CLIENT_PLUGIN_H
-#define UBUNTU_CLIENT_PLUGIN_H
+#ifndef QMIRCLIENTPLUGIN_H
+#define QMIRCLIENTPLUGIN_H
 
 #include <qpa/qplatformintegrationplugin.h>
 
-class UbuntuMirClientIntegrationPlugin : public QPlatformIntegrationPlugin
+class QMirClientIntegrationPlugin : public QPlatformIntegrationPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID QPlatformIntegrationFactoryInterface_iid FILE "mirclient.json")
@@ -29,4 +29,4 @@ public:
     QPlatformIntegration* create(const QString&, const QStringList&);
 };
 
-#endif // UBUNTU_CLIENT_PLUGIN_H
+#endif // QMIRCLIENTPLUGIN_H
diff --git a/src/plugins/platforms/mirclient/screen.cpp b/src/plugins/platforms/mirclient/qmirclientscreen.cpp
index 460761c4cb..7058d42d65 100644
--- a/src/plugins/platforms/mirclient/screen.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientscreen.cpp
@@ -25,9 +25,9 @@
 #include <QtPlatformSupport/private/qeglconvenience_p.h>
 
 // local
-#include "screen.h"
-#include "logging.h"
-#include "orientationchangeevent_p.h"
+#include "qmirclientscreen.h"
+#include "qmirclientlogging.h"
+#include "qmirclientorientationchangeevent_p.h"
 
 #include "memory"
 
@@ -125,7 +125,7 @@ static const MirDisplayOutput *find_active_output(
     return output;
 }
 
-UbuntuScreen::UbuntuScreen(MirConnection *connection)
+QMirClientScreen::QMirClientScreen(MirConnection *connection)
     : mFormat(QImage::Format_RGB32)
     , mDepth(32)
     , mSurfaceFormat()
@@ -191,7 +191,7 @@ UbuntuScreen::UbuntuScreen(MirConnection *connection)
 
     mGeometry = QRect(0, 0, kScreenWidth, kScreenHeight);
 
-    DLOG("QUbuntuScreen::QUbuntuScreen (this=%p)", this);
+    DLOG("QQMirClientScreen::QQMirClientScreen (this=%p)", this);
 
     // Set the default orientation based on the initial screen dimmensions.
     mNativeOrientation = (mGeometry.width() >= mGeometry.height()) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
@@ -200,12 +200,12 @@ UbuntuScreen::UbuntuScreen(MirConnection *connection)
     mCurrentOrientation = (mNativeOrientation == Qt::LandscapeOrientation) ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
 }
 
-UbuntuScreen::~UbuntuScreen()
+QMirClientScreen::~QMirClientScreen()
 {
     eglTerminate(mEglDisplay);
 }
 
-void UbuntuScreen::customEvent(QEvent* event) {
+void QMirClientScreen::customEvent(QEvent* event) {
     DASSERT(QThread::currentThread() == thread());
 
     OrientationChangeEvent* oReadingEvent = static_cast<OrientationChangeEvent*>(event);
@@ -231,17 +231,17 @@ void UbuntuScreen::customEvent(QEvent* event) {
             break;
         }
         default: {
-            DLOG("UbuntuScreen::customEvent - Unknown orientation.");
+            DLOG("QMirClientScreen::customEvent - Unknown orientation.");
             return;
         }
     }
 
     // Raise the event signal so that client apps know the orientation changed
-    DLOG("UbuntuScreen::customEvent - handling orientation change to %s", orientationToStr(mCurrentOrientation));
+    DLOG("QMirClientScreen::customEvent - handling orientation change to %s", orientationToStr(mCurrentOrientation));
     QWindowSystemInterface::handleScreenOrientationChange(screen(), mCurrentOrientation);
 }
 
-void UbuntuScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
+void QMirClientScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
 {
     if ((windowWidth > windowHeight && mGeometry.width() < mGeometry.height())
      || (windowWidth < windowHeight && mGeometry.width() > mGeometry.height())) {
@@ -258,7 +258,7 @@ void UbuntuScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
         mGeometry.setWidth(currGeometry.height());
         mGeometry.setHeight(currGeometry.width());
 
-        DLOG("UbuntuScreen::handleWindowSurfaceResize - new screen geometry (w=%d, h=%d)",
+        DLOG("QMirClientScreen::handleWindowSurfaceResize - new screen geometry (w=%d, h=%d)",
             mGeometry.width(), mGeometry.height());
         QWindowSystemInterface::handleScreenGeometryChange(screen(),
                                                            mGeometry /* newGeometry */,
@@ -269,7 +269,7 @@ void UbuntuScreen::handleWindowSurfaceResize(int windowWidth, int windowHeight)
         } else {
             mCurrentOrientation = Qt::LandscapeOrientation;
         }
-        DLOG("UbuntuScreen::handleWindowSurfaceResize - new orientation %s",orientationToStr(mCurrentOrientation));
+        DLOG("QMirClientScreen::handleWindowSurfaceResize - new orientation %s",orientationToStr(mCurrentOrientation));
         QWindowSystemInterface::handleScreenOrientationChange(screen(), mCurrentOrientation);
     }
 }
diff --git a/src/plugins/platforms/mirclient/screen.h b/src/plugins/platforms/mirclient/qmirclientscreen.h
index fa44f4cee9..0d544bf714 100644
--- a/src/plugins/platforms/mirclient/screen.h
+++ b/src/plugins/platforms/mirclient/qmirclientscreen.h
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_SCREEN_H
-#define UBUNTU_SCREEN_H
+#ifndef QMIRCLIENTSCREEN_H
+#define QMIRCLIENTSCREEN_H
 
 #include <qpa/qplatformscreen.h>
 #include <QSurfaceFormat>
@@ -23,12 +23,12 @@
 
 struct MirConnection;
 
-class UbuntuScreen : public QObject, public QPlatformScreen
+class QMirClientScreen : public QObject, public QPlatformScreen
 {
     Q_OBJECT
 public:
-    UbuntuScreen(MirConnection *connection);
-    virtual ~UbuntuScreen();
+    QMirClientScreen(MirConnection *connection);
+    virtual ~QMirClientScreen();
 
     // QPlatformScreen methods.
     QImage::Format format() const override { return mFormat; }
@@ -60,4 +60,4 @@ private:
     EGLNativeDisplayType mEglNativeDisplay;
 };
 
-#endif // UBUNTU_SCREEN_H
+#endif // QMIRCLIENTSCREEN_H
diff --git a/src/plugins/platforms/mirclient/theme.cpp b/src/plugins/platforms/mirclient/qmirclienttheme.cpp
index 31624fc4e8..e30de930d4 100644
--- a/src/plugins/platforms/mirclient/theme.cpp
+++ b/src/plugins/platforms/mirclient/qmirclienttheme.cpp
@@ -14,21 +14,21 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "theme.h"
+#include "qmirclienttheme.h"
 
 #include <QtCore/QVariant>
 
-const char *UbuntuTheme::name = "ubuntu";
+const char *QMirClientTheme::name = "ubuntu";
 
-UbuntuTheme::UbuntuTheme()
+QMirClientTheme::QMirClientTheme()
 {
 }
 
-UbuntuTheme::~UbuntuTheme()
+QMirClientTheme::~QMirClientTheme()
 {
 }
 
-QVariant UbuntuTheme::themeHint(ThemeHint hint) const
+QVariant QMirClientTheme::themeHint(ThemeHint hint) const
 {
     if (hint == QPlatformTheme::SystemIconThemeName) {
         QByteArray iconTheme = qgetenv("QTUBUNTU_ICON_THEME");
diff --git a/src/plugins/platforms/mirclient/theme.h b/src/plugins/platforms/mirclient/qmirclienttheme.h
index 5924f73c2f..d8a13c8352 100644
--- a/src/plugins/platforms/mirclient/theme.h
+++ b/src/plugins/platforms/mirclient/qmirclienttheme.h
@@ -14,20 +14,20 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_THEME_H
-#define UBUNTU_THEME_H
+#ifndef QMIRCLIENTTHEME_H
+#define QMIRCLIENTTHEME_H
 
 #include <QtPlatformSupport/private/qgenericunixthemes_p.h>
 
-class UbuntuTheme : public QGenericUnixTheme
+class QMirClientTheme : public QGenericUnixTheme
 {
 public:
     static const char* name;
-    UbuntuTheme();
-    virtual ~UbuntuTheme();
+    QMirClientTheme();
+    virtual ~QMirClientTheme();
 
     // From QPlatformTheme
     QVariant themeHint(ThemeHint hint) const override;
 };
 
-#endif // UBUNTU_THEME_H
+#endif // QMIRCLIENTTHEME_H
diff --git a/src/plugins/platforms/mirclient/window.cpp b/src/plugins/platforms/mirclient/qmirclientwindow.cpp
index dd37d78948..5f4136bf02 100644
--- a/src/plugins/platforms/mirclient/window.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientwindow.cpp
@@ -15,11 +15,11 @@
  */
 
 // Local
-#include "clipboard.h"
-#include "input.h"
-#include "window.h"
-#include "screen.h"
-#include "logging.h"
+#include "qmirclientclipboard.h"
+#include "qmirclientinput.h"
+#include "qmirclientwindow.h"
+#include "qmirclientscreen.h"
+#include "qmirclientlogging.h"
 
 // Qt
 #include <qpa/qwindowsysteminterface.h>
@@ -83,49 +83,49 @@ const char *qtWindowStateToStr(Qt::WindowState state)
 
 } // anonymous namespace
 
-class UbuntuWindowPrivate
+class QMirClientWindowPrivate
 {
 public:
     void createEGLSurface(EGLNativeWindowType nativeWindow);
     void destroyEGLSurface();
     int panelHeight();
 
-    UbuntuScreen* screen;
+    QMirClientScreen* screen;
     EGLSurface eglSurface;
     WId id;
-    UbuntuInput* input;
+    QMirClientInput* input;
     Qt::WindowState state;
     MirConnection *connection;
     MirSurface* surface;
     QSize bufferSize;
     QMutex mutex;
-    QSharedPointer<UbuntuClipboard> clipboard;
+    QSharedPointer<QMirClientClipboard> clipboard;
 };
 
 static void eventCallback(MirSurface* surface, const MirEvent *event, void* context)
 {
     (void) surface;
     DASSERT(context != NULL);
-    UbuntuWindow* platformWindow = static_cast<UbuntuWindow*>(context);
+    QMirClientWindow* platformWindow = static_cast<QMirClientWindow*>(context);
     platformWindow->priv()->input->postEvent(platformWindow, event);
 }
 
 static void surfaceCreateCallback(MirSurface* surface, void* context)
 {
     DASSERT(context != NULL);
-    UbuntuWindow* platformWindow = static_cast<UbuntuWindow*>(context);
+    QMirClientWindow* platformWindow = static_cast<QMirClientWindow*>(context);
     platformWindow->priv()->surface = surface;
 
     mir_surface_set_event_handler(surface, eventCallback, context);
 }
 
-UbuntuWindow::UbuntuWindow(QWindow* w, QSharedPointer<UbuntuClipboard> clipboard, UbuntuScreen* screen,
-                           UbuntuInput* input, MirConnection* connection)
+QMirClientWindow::QMirClientWindow(QWindow* w, QSharedPointer<QMirClientClipboard> clipboard, QMirClientScreen* screen,
+                           QMirClientInput* input, MirConnection* connection)
     : QObject(nullptr), QPlatformWindow(w)
 {
     DASSERT(screen != NULL);
 
-    d = new UbuntuWindowPrivate;
+    d = new QMirClientWindowPrivate;
     d->screen = screen;
     d->eglSurface = EGL_NO_SURFACE;
     d->input = input;
@@ -140,12 +140,12 @@ UbuntuWindow::UbuntuWindow(QWindow* w, QSharedPointer<UbuntuClipboard> clipboard
     QPlatformWindow::setGeometry(window()->geometry() != screen->geometry() ?
         window()->geometry() : screen->availableGeometry());
     createWindow();
-    DLOG("UbuntuWindow::UbuntuWindow (this=%p, w=%p, screen=%p, input=%p)", this, w, screen, input);
+    DLOG("QMirClientWindow::QMirClientWindow (this=%p, w=%p, screen=%p, input=%p)", this, w, screen, input);
 }
 
-UbuntuWindow::~UbuntuWindow()
+QMirClientWindow::~QMirClientWindow()
 {
-    DLOG("UbuntuWindow::~UbuntuWindow");
+    DLOG("QMirClientWindow::~QMirClientWindow");
     d->destroyEGLSurface();
 
     mir_surface_release_sync(d->surface);
@@ -153,9 +153,9 @@ UbuntuWindow::~UbuntuWindow()
     delete d;
 }
 
-void UbuntuWindowPrivate::createEGLSurface(EGLNativeWindowType nativeWindow)
+void QMirClientWindowPrivate::createEGLSurface(EGLNativeWindowType nativeWindow)
 {
-  DLOG("UbuntuWindowPrivate::createEGLSurface (this=%p, nativeWindow=%p)",
+  DLOG("QMirClientWindowPrivate::createEGLSurface (this=%p, nativeWindow=%p)",
           this, reinterpret_cast<void*>(nativeWindow));
 
   eglSurface = eglCreateWindowSurface(screen->eglDisplay(), screen->eglConfig(),
@@ -164,9 +164,9 @@ void UbuntuWindowPrivate::createEGLSurface(EGLNativeWindowType nativeWindow)
   DASSERT(eglSurface != EGL_NO_SURFACE);
 }
 
-void UbuntuWindowPrivate::destroyEGLSurface()
+void QMirClientWindowPrivate::destroyEGLSurface()
 {
-    DLOG("UbuntuWindowPrivate::destroyEGLSurface (this=%p)", this);
+    DLOG("QMirClientWindowPrivate::destroyEGLSurface (this=%p)", this);
     if (eglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(screen->eglDisplay(), eglSurface);
         eglSurface = EGL_NO_SURFACE;
@@ -175,7 +175,7 @@ void UbuntuWindowPrivate::destroyEGLSurface()
 
 // FIXME - in order to work around https://bugs.launchpad.net/mir/+bug/1346633
 // we need to guess the panel height (3GU + 2DP)
-int UbuntuWindowPrivate::panelHeight()
+int QMirClientWindowPrivate::panelHeight()
 {
     const int defaultGridUnit = 8;
     int gridUnit = defaultGridUnit;
@@ -206,9 +206,9 @@ mir_choose_default_pixel_format(MirConnection *connection)
 }
 }
 
-void UbuntuWindow::createWindow()
+void QMirClientWindow::createWindow()
 {
-    DLOG("UbuntuWindow::createWindow (this=%p)", this);
+    DLOG("QMirClientWindow::createWindow (this=%p)", this);
 
     // FIXME: remove this remnant of an old platform-api enum - needs ubuntu-keyboard update
     const int SCREEN_KEYBOARD_ROLE = 7;
@@ -236,10 +236,10 @@ void UbuntuWindow::createWindow()
     // Get surface geometry.
     QRect geometry;
     if (d->state == Qt::WindowFullScreen) {
-        printf("UbuntuWindow - fullscreen geometry\n");
+        printf("QMirClientWindow - fullscreen geometry\n");
         geometry = screen()->geometry();
     } else if (d->state == Qt::WindowMaximized) {
-        printf("UbuntuWindow - maximized geometry\n");
+        printf("QMirClientWindow - maximized geometry\n");
         geometry = screen()->availableGeometry();
         /*
          * FIXME: Autopilot relies on being able to convert coordinates relative of the window
@@ -251,7 +251,7 @@ void UbuntuWindow::createWindow()
          */
         geometry.setY(panelHeight);
     } else {
-        printf("UbuntuWindow - regular geometry\n");
+        printf("QMirClientWindow - regular geometry\n");
         geometry = this->geometry();
         geometry.setY(panelHeight);
     }
@@ -305,16 +305,16 @@ void UbuntuWindow::createWindow()
     QPlatformWindow::setGeometry(geometry);
 }
 
-void UbuntuWindow::moveResize(const QRect& rect)
+void QMirClientWindow::moveResize(const QRect& rect)
 {
     (void) rect;
     // TODO: Not yet supported by mir.
 }
 
-void UbuntuWindow::handleSurfaceResize(int width, int height)
+void QMirClientWindow::handleSurfaceResize(int width, int height)
 {
     QMutexLocker(&d->mutex);
-    LOG("UbuntuWindow::handleSurfaceResize(width=%d, height=%d)", width, height);
+    LOG("QMirClientWindow::handleSurfaceResize(width=%d, height=%d)", width, height);
 
     // The current buffer size hasn't actually changed. so just render on it and swap
     // buffers in the hope that the next buffer will match the surface size advertised
@@ -329,9 +329,9 @@ void UbuntuWindow::handleSurfaceResize(int width, int height)
     }
 }
 
-void UbuntuWindow::handleSurfaceFocusChange(bool focused)
+void QMirClientWindow::handleSurfaceFocusChange(bool focused)
 {
-    LOG("UbuntuWindow::handleSurfaceFocusChange(focused=%s)", focused ? "true" : "false");
+    LOG("QMirClientWindow::handleSurfaceFocusChange(focused=%s)", focused ? "true" : "false");
     QWindow *activatedWindow = focused ? window() : nullptr;
 
     // System clipboard contents might have changed while this window was unfocused and wihtout
@@ -347,10 +347,10 @@ void UbuntuWindow::handleSurfaceFocusChange(bool focused)
     QWindowSystemInterface::handleWindowActivated(activatedWindow, Qt::ActiveWindowFocusReason);
 }
 
-void UbuntuWindow::setWindowState(Qt::WindowState state)
+void QMirClientWindow::setWindowState(Qt::WindowState state)
 {
     QMutexLocker(&d->mutex);
-    DLOG("UbuntuWindow::setWindowState (this=%p, %s)", this,  qtWindowStateToStr(state));
+    DLOG("QMirClientWindow::setWindowState (this=%p, %s)", this,  qtWindowStateToStr(state));
 
     if (state == d->state)
         return;
@@ -360,9 +360,9 @@ void UbuntuWindow::setWindowState(Qt::WindowState state)
     d->state = state;
 }
 
-void UbuntuWindow::setGeometry(const QRect& rect)
+void QMirClientWindow::setGeometry(const QRect& rect)
 {
-    DLOG("UbuntuWindow::setGeometry (this=%p)", this);
+    DLOG("QMirClientWindow::setGeometry (this=%p)", this);
 
     bool doMoveResize;
 
@@ -377,10 +377,10 @@ void UbuntuWindow::setGeometry(const QRect& rect)
     }
 }
 
-void UbuntuWindow::setVisible(bool visible)
+void QMirClientWindow::setVisible(bool visible)
 {
     QMutexLocker(&d->mutex);
-    DLOG("UbuntuWindow::setVisible (this=%p, visible=%s)", this, visible ? "true" : "false");
+    DLOG("QMirClientWindow::setVisible (this=%p, visible=%s)", this, visible ? "true" : "false");
 
     if (visible) {
         mir_wait_for(mir_surface_set_state(d->surface, qtWindowStateToMirSurfaceState(d->state)));
@@ -394,17 +394,17 @@ void UbuntuWindow::setVisible(bool visible)
     }
 }
 
-void* UbuntuWindow::eglSurface() const
+void* QMirClientWindow::eglSurface() const
 {
     return d->eglSurface;
 }
 
-WId UbuntuWindow::winId() const
+WId QMirClientWindow::winId() const
 {
     return d->id;
 }
 
-void UbuntuWindow::onBuffersSwapped_threadSafe(int newBufferWidth, int newBufferHeight)
+void QMirClientWindow::onBuffersSwapped_threadSafe(int newBufferWidth, int newBufferHeight)
 {
     QMutexLocker(&d->mutex);
 
@@ -413,7 +413,7 @@ void UbuntuWindow::onBuffersSwapped_threadSafe(int newBufferWidth, int newBuffer
     if (sizeKnown && (d->bufferSize.width() != newBufferWidth ||
                 d->bufferSize.height() != newBufferHeight)) {
 
-        DLOG("UbuntuWindow::onBuffersSwapped_threadSafe - buffer size changed from (%d,%d) to (%d,%d)",
+        DLOG("QMirClientWindow::onBuffersSwapped_threadSafe - buffer size changed from (%d,%d) to (%d,%d)",
                 d->bufferSize.width(), d->bufferSize.height(), newBufferWidth, newBufferHeight);
 
         d->bufferSize.rwidth() = newBufferWidth;
diff --git a/src/plugins/platforms/mirclient/window.h b/src/plugins/platforms/mirclient/qmirclientwindow.h
index 64365789e6..29293441b8 100644
--- a/src/plugins/platforms/mirclient/window.h
+++ b/src/plugins/platforms/mirclient/qmirclientwindow.h
@@ -14,26 +14,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef UBUNTU_WINDOW_H
-#define UBUNTU_WINDOW_H
+#ifndef QMIRCLIENTWINDOW_H
+#define QMIRCLIENTWINDOW_H
 
 #include <qpa/qplatformwindow.h>
 #include <QSharedPointer>
 
 #include <mir_toolkit/mir_client_library.h>
 
-class UbuntuClipboard;
-class UbuntuInput;
-class UbuntuScreen;
-class UbuntuWindowPrivate;
+class QMirClientClipboard;
+class QMirClientInput;
+class QMirClientScreen;
+class QMirClientWindowPrivate;
 
-class UbuntuWindow : public QObject, public QPlatformWindow
+class QMirClientWindow : public QObject, public QPlatformWindow
 {
     Q_OBJECT
 public:
-    UbuntuWindow(QWindow *w, QSharedPointer<UbuntuClipboard> clipboard, UbuntuScreen *screen,
-                 UbuntuInput *input, MirConnection *mir_connection);
-    virtual ~UbuntuWindow();
+    QMirClientWindow(QWindow *w, QSharedPointer<QMirClientClipboard> clipboard, QMirClientScreen *screen,
+                 QMirClientInput *input, MirConnection *mir_connection);
+    virtual ~QMirClientWindow();
 
     // QPlatformWindow methods.
     WId winId() const override;
@@ -47,13 +47,13 @@ public:
     void handleSurfaceFocusChange(bool focused);
     void onBuffersSwapped_threadSafe(int newBufferWidth, int newBufferHeight);
 
-    UbuntuWindowPrivate* priv() { return d; }
+    QMirClientWindowPrivate* priv() { return d; }
 
 private:
     void createWindow();
     void moveResize(const QRect& rect);
 
-    UbuntuWindowPrivate *d;
+    QMirClientWindowPrivate *d;
 };
 
-#endif // UBUNTU_WINDOW_H
+#endif // QMIRCLIENTWINDOW_H