Merge lp:~dandrader/qtubuntu/dbusClipboard into lp:qtubuntu

[Daniel d'Andrada]

Use the global clipboard from D-Bus

Needs https://code.launchpad.net/~dandrader/qtmir/dbusClipboard/+merge/235501

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:243
http://jenkins.qa.ubuntu.com/job/qtubuntu-ci/162/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-utopic-armhf-ci/28
        deb: http://jenkins.qa.ubuntu.com/job/qtubuntu-utopic-armhf-ci/28/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-ci/162/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

Why the commenting of debug statements at 412? Beyond that seems ok. The assert in serialization is less concerning on the client side than the server side.

review: Approve

[Daniel d'Andrada (dandrader)]

> Why the commenting of debug statements at 412?

Because they're ridiculously verbose. A simple swipe produces dozens of lines. So I think it's better for them to be an opt-in thing that you manually enable when you're debugging events. But yeah, not directly related to the objective of that MP.

[lp:~dandrader/qtubuntu/dbusClipboard]

244. By Daniel d'Andrada on 2014-09-23

Implement contents size limitation on the global clipboard

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:244
http://jenkins.qa.ubuntu.com/job/qtubuntu-ci/164/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-utopic-armhf-ci/30
        deb: http://jenkins.qa.ubuntu.com/job/qtubuntu-utopic-armhf-ci/30/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-ci/164/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

thanks for applying fixes from other branch!

=== modified file 'src/ubuntumirclient/clipboard.cpp'
--- src/ubuntumirclient/clipboard.cpp	2014-06-18 23:10:00 +0000
+++ src/ubuntumirclient/clipboard.cpp	2014-09-23 11:49:39 +0000
@@ -18,9 +18,9 @@
 
 #include <QtCore/QMimeData>
 #include <QtCore/QStringList>
-
-// Platform API
-#include <ubuntu/application/ui/clipboard.h>
+#include <QDBusInterface>
+#include <QDBusPendingCallWatcher>
+#include <QDBusPendingReply>
 
 // FIXME(loicm) The clipboard data format is not defined by Ubuntu Platform API
 //     which makes it impossible to have non-Qt applications communicate with Qt
@@ -29,19 +29,26 @@
 //     embedding different mime types in the clipboard.
 
 // Data format:
-//   number of mime types      (4 bytes)
-//   data layout               (16 bytes * number of mime types)
-//     mime type string offset (4 bytes)
-//     mime type string size   (4 bytes)
-//     data offset             (4 bytes)
-//     data size               (4 bytes)
+//   number of mime types      (sizeof(int))
+//   data layout               ((4 * sizeof(int)) * number of mime types)
+//     mime type string offset (sizeof(int))
+//     mime type string size   (sizeof(int))
+//     data offset             (sizeof(int))
+//     data size               (sizeof(int))
 //   data                      (n bytes)
 
+namespace {
+
 const int maxFormatsCount = 16;
 const int maxBufferSize = 4 * 1024 * 1024;  // 4 Mb
 
+}
+
 UbuntuClipboard::UbuntuClipboard()
     : mMimeData(new QMimeData)
+    , mIsOutdated(true)
+    , mUpdatesDisabled(false)
+    , mDBusSetupDone(false)
 {
 }
 
@@ -50,80 +57,200 @@
     delete mMimeData;
 }
 
+void UbuntuClipboard::requestDBusClipboardContents()
+{
+    if (!mDBusSetupDone) {
+        setupDBus();
+    }
+
+    if (!mPendingGetContentsCall.isNull())
+        return;
+
+    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall("GetContents");
+
+    mPendingGetContentsCall = new QDBusPendingCallWatcher(pendingCall, this);
+
+    QObject::connect(mPendingGetContentsCall.data(), SIGNAL(finished(QDBusPendingCallWatcher*)),
+                     this, SLOT(onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher*)));
+}
+
+void UbuntuClipboard::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",
+                qPrintable(reply.error().name()), qPrintable(reply.error().message()));
+        // TODO: Might try again later a number of times...
+    } else {
+        QByteArray serializedMimeData = reply.argumentAt<0>();
+        updateMimeData(serializedMimeData);
+    }
+    call->deleteLater();
+}
+
+void UbuntuClipboard::onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher *call)
+{
+    QDBusPendingReply<void> reply = *call;
+    if (reply.isError()) {
+        qCritical("UbuntuClipboard - 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)
+{
+    if (mUpdatesDisabled)
+        return;
+
+    QMimeData *newMimeData = deserializeMimeData(serializedMimeData);
+    if (newMimeData) {
+        delete mMimeData;
+        mMimeData = newMimeData;
+        mIsOutdated = false;
+        emitChanged(QClipboard::Clipboard);
+    } else {
+        qWarning("UbuntuClipboard - Got invalid serialized mime data. Ignoring it.");
+    }
+}
+
+void UbuntuClipboard::setupDBus()
+{
+    QDBusConnection dbusConnection = QDBusConnection::sessionBus();
+
+    bool ok = dbusConnection.connect(
+            "com.canonical.QtMir",
+            "/com/canonical/QtMir/Clipboard",
+            "com.canonical.QtMir.Clipboard",
+            "ContentsChanged",
+            this, SLOT(updateMimeData(QByteArray)));
+    if (!ok) {
+        qCritical("UbuntuClipboard - Failed to connect to ContentsChanged signal form the D-Bus system clipboard.");
+    }
+
+    mDBusClipboard = new QDBusInterface("com.canonical.QtMir",
+            "/com/canonical/QtMir/Clipboard",
+            "com.canonical.QtMir.Clipboard",
+            dbusConnection);
+
+    mDBusSetupDone = true;
+}
+
+QByteArray UbuntuClipboard::serializeMimeData(QMimeData *mimeData) const
+{
+    const QStringList formats = mimeData->formats();
+    const int formatCount = qMin(formats.size(), maxFormatsCount);
+    const int headerSize = sizeof(int) + (formatCount * 4 * sizeof(int));
+    int bufferSize = headerSize;
+
+    for (int i = 0; i < formatCount; i++)
+        bufferSize += formats[i].size() + mimeData->data(formats[i]).size();
+
+    QByteArray serializedMimeData;
+    if (bufferSize <= maxBufferSize) {
+        // Serialize data.
+        serializedMimeData.resize(bufferSize);
+        {
+            char *buffer = serializedMimeData.data();
+            int* header = reinterpret_cast<int*>(serializedMimeData.data());
+            int offset = headerSize;
+            header[0] = formatCount;
+            for (int i = 0; i < formatCount; i++) {
+                const int formatOffset = offset;
+                const int formatSize = formats[i].size();
+                const int dataOffset = offset + formatSize;
+                const int dataSize = mimeData->data(formats[i]).size();
+                memcpy(&buffer[formatOffset], formats[i].toLatin1().data(), formatSize);
+                memcpy(&buffer[dataOffset], mimeData->data(formats[i]).data(), dataSize);
+                header[i*4+1] = formatOffset;
+                header[i*4+2] = formatSize;
+                header[i*4+3] = dataOffset;
+                header[i*4+4] = dataSize;
+                offset += formatSize + dataSize;
+            }
+        }
+    } else {
+        qWarning("UbuntuClipboard: 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
+{
+    if (static_cast<std::size_t>(serializedMimeData.size()) < sizeof(int)) {
+        // Data is invalid
+        return nullptr;
+    }
+
+    QMimeData *mimeData = new QMimeData;
+
+    const char* const buffer = serializedMimeData.constData();
+    const int* const header = reinterpret_cast<const int*>(serializedMimeData.constData());
+
+    const int count = qMin(header[0], maxFormatsCount);
+
+    for (int i = 0; i < count; i++) {
+        const int formatOffset = header[i*4+1];
+        const int formatSize = header[i*4+2];
+        const int dataOffset = header[i*4+3];
+        const int dataSize = header[i*4+4];
+
+        if (formatOffset + formatSize <= serializedMimeData.size()
+                && dataOffset + dataSize <= serializedMimeData.size()) {
+
+            QString mimeType = QString::fromLatin1(&buffer[formatOffset], formatSize);
+            QByteArray mimeDataBytes(&buffer[dataOffset], dataSize);
+
+            mimeData->setData(mimeType, mimeDataBytes);
+        }
+    }
+
+    return mimeData;
+}
+
 QMimeData* UbuntuClipboard::mimeData(QClipboard::Mode mode)
 {
-    Q_UNUSED(mode);
-    // Get clipboard data.
-    void* data = NULL;
-    size_t size = 0;
-    ua_ui_get_clipboard_content(&data, &size);
+    if (mode != QClipboard::Clipboard)
+        return nullptr;
 
-    // Deserialize, update and return mime data taking care of incorrectly
-    // formatted input.
-    mMimeData->clear();
-    if (static_cast<size_t>(size) > sizeof(int)  // Should be at least that big to read the count.
-            && data != NULL) {
-        const char* const buffer = reinterpret_cast<char*>(data);
-        const int* const header = reinterpret_cast<int*>(data);
-        const int count = qMin(header[0], maxFormatsCount);
-        for (int i = 0; i < count; i++) {
-            const unsigned int formatOffset = header[i*4+1];
-            const unsigned int formatSize = header[i*4+2];
-            const unsigned int dataOffset = header[i*4+3];
-            const unsigned int dataSize = header[i*4+4];
-            if (formatOffset + formatSize <= size && dataOffset + dataSize <= size) {
-                mMimeData->setData(QString(&buffer[formatOffset]),
-                        QByteArray(&buffer[dataOffset], dataSize));
-            }
-        }
+    if (mIsOutdated && mPendingGetContentsCall.isNull()) {
+        requestDBusClipboardContents();
     }
+
+    // Return whatever we have at the moment instead of blocking until we have something.
+    //
+    // This might be called during app startup just for the sake of checking if some
+    // "Paste" UI control should be enabled or not.
+    // We will emit QClipboard::changed() once we finally have something.
     return mMimeData;
 }
 
 void UbuntuClipboard::setMimeData(QMimeData* mimeData, QClipboard::Mode mode)
 {
-    Q_UNUSED(mode);
-    if (mimeData == NULL) {
-        ua_ui_set_clipboard_content(NULL, 0);
+    if (mode != QClipboard::Clipboard)
         return;
-    }
-
-    const QStringList formats = mimeData->formats();
-    const int count = qMin(formats.size(), maxFormatsCount);
-    const int headerSize = sizeof(int) + count * 4 * sizeof(int);
-    int bufferSize = headerSize;
-    char* buffer;
-
-    // Get the buffer size considering the header size, the NULL-terminated
-    // formats and the non NULL-terminated data.
-    for (int i = 0; i < count; i++)
-        bufferSize += formats[i].size() + 1 + mimeData->data(formats[i]).size();
-    // FIXME(loicm) Implement max buffer size limitation.
-    // FIXME(loicm) Remove ASSERT before release.
-    Q_ASSERT(bufferSize <= maxBufferSize);
-
-    // Serialize data.
-    buffer = new char[bufferSize];
-    int* header = reinterpret_cast<int*>(buffer);
-    int offset = headerSize;
-    header[0] = count;
-    for (int i = 0; i < count; i++) {
-        const int formatOffset = offset;
-        const int formatSize = formats[i].size() + 1;
-        const int dataOffset = offset + formatSize;
-        const int dataSize = mimeData->data(formats[i]).size();
-        memcpy(&buffer[formatOffset], formats[i].toLatin1().data(), formatSize);
-        memcpy(&buffer[dataOffset], mimeData->data(formats[i]).data(), dataSize);
-        header[i*4+1] = formatOffset;
-        header[i*4+2] = formatSize;
-        header[i*4+3] = dataOffset;
-        header[i*4+4] = dataSize;
-        offset += formatSize + dataSize;
-    }
-
-    // Set clipboard content.
-    ua_ui_set_clipboard_content(reinterpret_cast<void*>(buffer), bufferSize);
-    delete [] buffer;
+
+    if (!mPendingGetContentsCall.isNull()) {
+        // Ignore whatever comes from the system clipboard as we are going to change it anyway
+        QObject::disconnect(mPendingGetContentsCall.data(), 0, this, 0);
+        mUpdatesDisabled = true;
+        mPendingGetContentsCall->waitForFinished();
+        mUpdatesDisabled = false;
+        delete mPendingGetContentsCall.data();
+    }
+
+    QByteArray serializedMimeData = serializeMimeData(mimeData);
+    if (!serializedMimeData.isEmpty()) {
+        setDBusClipboardContents(serializedMimeData);
+    }
+
+    mMimeData = mimeData;
+    emitChanged(QClipboard::Clipboard);
 }
 
 bool UbuntuClipboard::supportsMode(QClipboard::Mode mode) const
@@ -136,3 +263,22 @@
     Q_UNUSED(mode);
     return false;
 }
+
+void UbuntuClipboard::setDBusClipboardContents(const QByteArray &clipboardContents)
+{
+    if (!mPendingSetContentsCall.isNull()) {
+        // Ignore any previous set call as we are going to overwrite it anyway
+        QObject::disconnect(mPendingSetContentsCall.data(), 0, this, 0);
+        mUpdatesDisabled = true;
+        mPendingSetContentsCall->waitForFinished();
+        mUpdatesDisabled = false;
+        delete mPendingSetContentsCall.data();
+    }
+
+    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall("SetContents", clipboardContents);
+
+    mPendingSetContentsCall = new QDBusPendingCallWatcher(pendingCall, this);
+
+    QObject::connect(mPendingSetContentsCall.data(), SIGNAL(finished(QDBusPendingCallWatcher*)),
+                     this, SLOT(onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher*)));
+}

=== modified file 'src/ubuntumirclient/clipboard.h'
--- src/ubuntumirclient/clipboard.h	2014-06-18 23:10:00 +0000
+++ src/ubuntumirclient/clipboard.h	2014-09-23 11:49:39 +0000
@@ -19,8 +19,14 @@
 
 #include <qpa/qplatformclipboard.h>
 
-class UbuntuClipboard : public QPlatformClipboard
+#include <QMimeData>
+#include <QPointer>
+class QDBusInterface;
+class QDBusPendingCallWatcher;
+
+class UbuntuClipboard : public QObject, public QPlatformClipboard
 {
+    Q_OBJECT
 public:
     UbuntuClipboard();
     virtual ~UbuntuClipboard();
@@ -31,8 +37,31 @@
     bool supportsMode(QClipboard::Mode mode) const override;
     bool ownsMode(QClipboard::Mode mode) const override;
 
+    void requestDBusClipboardContents();
+
+private Q_SLOTS:
+    void onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher*);
+    void onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher*);
+    void updateMimeData(const QByteArray &serializedMimeData);
+
 private:
-    QMimeData* mMimeData;
+    void setupDBus();
+
+    QByteArray serializeMimeData(QMimeData *mimeData) const;
+    QMimeData *deserializeMimeData(const QByteArray &serializedMimeData) const;
+
+    void setDBusClipboardContents(const QByteArray &clipboardContents);
+
+    QMimeData *mMimeData;
+    bool mIsOutdated;
+
+    QPointer<QDBusInterface> mDBusClipboard;
+
+    QPointer<QDBusPendingCallWatcher> mPendingGetContentsCall;
+    QPointer<QDBusPendingCallWatcher> mPendingSetContentsCall;
+
+    bool mUpdatesDisabled;
+    bool mDBusSetupDone;
 };
 
 #endif // UBUNTU_CLIPBOARD_H

=== modified file 'src/ubuntumirclient/input.cpp'
--- src/ubuntumirclient/input.cpp	2014-08-14 09:45:04 +0000
+++ src/ubuntumirclient/input.cpp	2014-09-23 11:49:39 +0000
@@ -160,6 +160,7 @@
 }
 
 #ifndef QT_NO_DEBUG
+/*
 static const char* nativeEventTypeToStr(int eventType)
 {
     switch (eventType) {
@@ -178,6 +179,7 @@
         return "INVALID!";
     }
 }
+*/
 #endif
 
 void UbuntuInput::customEvent(QEvent* event)
@@ -199,7 +201,7 @@
         return;
     }
 
-    DLOG("UbuntuInput::customEvent(type=%s)", nativeEventTypeToStr(nativeEvent->type));
+    //DLOG("UbuntuInput::customEvent(type=%s)", nativeEventTypeToStr(nativeEvent->type));
 
     // Event dispatching.
     switch (nativeEvent->type) {

=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2014-08-05 16:02:48 +0000
+++ src/ubuntumirclient/integration.cpp	2014-09-23 11:49:39 +0000
@@ -108,7 +108,6 @@
 
 UbuntuClientIntegration::~UbuntuClientIntegration()
 {
-    delete mClipboard;
     delete mInput;
     delete mInputContext;
     delete mScreen;
@@ -157,7 +156,7 @@
 QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window)
 {
     QPlatformWindow* platformWindow = new UbuntuWindow(
-            window, static_cast<UbuntuScreen*>(mScreen), mInput, mInstance);
+            window, mClipboard, static_cast<UbuntuScreen*>(mScreen), mInput, mInstance);
     platformWindow->requestActivateWindow();
     return platformWindow;
 }
@@ -233,3 +232,8 @@
     }
     return QPlatformIntegration::styleHint(hint);
 }
+
+QPlatformClipboard* UbuntuClientIntegration::clipboard() const
+{
+    return mClipboard.data();
+}

=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2014-08-05 16:02:48 +0000
+++ src/ubuntumirclient/integration.h	2014-09-23 11:49:39 +0000
@@ -18,6 +18,7 @@
 #define UBUNTU_CLIENT_INTEGRATION_H
 
 #include <qpa/qplatformintegration.h>
+#include <QSharedPointer>
 
 #include "platformservices.h"
 
@@ -27,6 +28,7 @@
 #include <ubuntu/application/ui/options.h>
 #include <ubuntu/application/ui/session.h>
 
+class UbuntuClipboard;
 class UbuntuInput;
 class UbuntuScreen;
 
@@ -48,7 +50,7 @@
     QPlatformServices *services() const override;
     QPlatformWindow* createPlatformWindow(QWindow* window) const override;
     QPlatformInputContext* inputContext() const override { return mInputContext; }
-    QPlatformClipboard* clipboard() const override { return mClipboard; }
+    QPlatformClipboard* clipboard() const override;
 
     QPlatformOpenGLContext* createPlatformOpenGLContext(QOpenGLContext* context);
     QPlatformWindow* createPlatformWindow(QWindow* window);
@@ -66,7 +68,7 @@
     UbuntuScreen* mScreen;
     UbuntuInput* mInput;
     QPlatformInputContext* mInputContext;
-    QPlatformClipboard* mClipboard;
+    QSharedPointer<UbuntuClipboard> mClipboard;
     qreal mScaleFactor;
 
     // Platform API stuff

=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2014-08-14 13:18:24 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2014-09-23 11:49:39 +0000
@@ -2,7 +2,7 @@
 TEMPLATE = lib
 
 QT -= gui
-QT += core-private gui-private platformsupport-private sensors
+QT += core-private gui-private platformsupport-private sensors dbus
 
 CONFIG += plugin no_keywords qpa/genericunixfontdatabase
 

=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2014-08-08 14:04:13 +0000
+++ src/ubuntumirclient/window.cpp	2014-09-23 11:49:39 +0000
@@ -15,6 +15,7 @@
  */
 
 // Local
+#include "clipboard.h"
 #include "input.h"
 #include "window.h"
 #include "screen.h"
@@ -55,17 +56,17 @@
     QSize bufferSize;
     QSize targetBufferSize;
     QMutex mutex;
+    QSharedPointer<UbuntuClipboard> clipboard;
 };
 
 static void eventCallback(void* context, const WindowEvent* event)
 {
-    DLOG("eventCallback (context=%p, event=%p)", context, event);
     DASSERT(context != NULL);
     UbuntuWindow* platformWindow = static_cast<UbuntuWindow*>(context);
     platformWindow->priv()->input->postEvent(platformWindow, event);
 }
 
-UbuntuWindow::UbuntuWindow(QWindow* w, UbuntuScreen* screen,
+UbuntuWindow::UbuntuWindow(QWindow* w, QSharedPointer<UbuntuClipboard> clipboard, UbuntuScreen* screen,
                            UbuntuInput* input, UApplicationInstance* instance)
     : QObject(nullptr), QPlatformWindow(w)
 {
@@ -77,6 +78,7 @@
     d->input = input;
     d->state = window()->windowState();
     d->uaInstance = instance;
+    d->clipboard = clipboard;
 
     static int id = 1;
     d->id = id++;
@@ -265,6 +267,17 @@
 {
     LOG("UbuntuWindow::handleSurfaceFocusChange(focused=%s)", focused ? "true" : "false");
     QWindow *activatedWindow = focused ? window() : nullptr;
+
+    // System clipboard contents might have changed while this window was unfocused and wihtout
+    // this process getting notified about it because it might have been suspended (due to
+    // application lifecycle policies), thus unable to listen to any changes notified through
+    // D-Bus.
+    // Therefore let's ensure we are up to date with the system clipboard now that we are getting
+    // focused again.
+    if (focused) {
+        d->clipboard->requestDBusClipboardContents();
+    }
+
     QWindowSystemInterface::handleWindowActivated(activatedWindow, Qt::ActiveWindowFocusReason);
 }
 

=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2014-08-08 12:05:21 +0000
+++ src/ubuntumirclient/window.h	2014-09-23 11:49:39 +0000
@@ -18,7 +18,9 @@
 #define UBUNTU_WINDOW_H
 
 #include <qpa/qplatformwindow.h>
+#include <QSharedPointer>
 
+class UbuntuClipboard;
 class UbuntuInput;
 class UbuntuScreen;
 class UbuntuWindowPrivate;
@@ -27,7 +29,7 @@
 {
     Q_OBJECT
 public:
-    UbuntuWindow(QWindow* w, UbuntuScreen* screen,
+    UbuntuWindow(QWindow* w, QSharedPointer<UbuntuClipboard> clipboard, UbuntuScreen* screen,
                  UbuntuInput* input, void* instance);
     virtual ~UbuntuWindow();