Remove the buffer queue.

A client calling attach(A);commit();attach(B);commit() should result
in its back buffer be set to B, and A be discarded.
If the client wants to have a queue it should keep it client side or
a protocol extension tailored for that purpose should be developed.

Change-Id: Ia0048f311504d85821df9f5b9225887801efec71
Reviewed-by: Jørgen Lind <jorgen.lind@digia.com>

1 files changed, 30 insertions, 71 deletions

diff --git a/src/compositor/wayland_wrapper/qwlsurface.cpp b/src/compositor/wayland_wrapper/qwlsurface.cpp
index 79b83ab7e..a0e61bc22 100644
--- a/src/compositor/wayland_wrapper/qwlsurface.cpp
+++ b/src/compositor/wayland_wrapper/qwlsurface.cpp
@@ -129,6 +129,8 @@ Surface::Surface(struct wl_client *client, uint32_t id, Compositor *compositor)
     , m_transientInactive(false)
     , m_isCursorSurface(false)
 {
+    m_pending.buffer = 0;
+    m_pending.newlyAttached = false;
 }
 
 Surface::~Surface()
@@ -335,7 +337,7 @@ Compositor *Surface::compositor() const
     return m_compositor;
 }
 
-void Surface::advanceBufferQueue()
+void Surface::swapBuffers()
  {
     SurfaceBuffer *front = m_frontBuffer;
 
@@ -349,16 +351,6 @@ void Surface::advanceBufferQueue()
         m_backBuffer = 0;
     }
 
-    // Set a new back buffer if there is something in the queue.
-    if (m_bufferQueue.size() && m_bufferQueue.first()->isComitted()) {
-        SurfaceBuffer *next = m_bufferQueue.takeFirst();
-        while (next && next->isDestroyed()) {
-            next->disown();
-            next = m_bufferQueue.size() ? m_bufferQueue.takeFirst() : 0;
-        }
-        setBackBuffer(next);
-    }
-
     // Release the old front buffer if we changed it.
     if (front && front != m_frontBuffer)
         front->disown();
@@ -366,7 +358,7 @@ void Surface::advanceBufferQueue()
 
 /*!
  * Sets the backbuffer for this surface. The back buffer is not yet on
- * screen and will become live during the next advanceBufferQueue().
+ * screen and will become live during the next swapBuffers().
  *
  * The backbuffer represents the current state of the surface for the
  * purpose of GUI-thread accessible properties such as size and visibility.
@@ -387,7 +379,8 @@ void Surface::setBackBuffer(SurfaceBuffer *buffer)
              emit m_waylandSurface->unmapped();
         }
 
-        emit m_waylandSurface->damaged(m_backBuffer->damageRect());
+        m_damage = m_damage.intersected(QRect(QPoint(), m_size));
+        emit m_waylandSurface->damaged(m_damage);
     } else {
         InputDevice *inputDevice = m_compositor->defaultInputDevice();
         if (inputDevice->keyboardFocus() == this)
@@ -395,6 +388,7 @@ void Surface::setBackBuffer(SurfaceBuffer *buffer)
         if (inputDevice->mouseFocus() == this)
             inputDevice->setMouseFocus(0, QPointF(), QPointF());
     }
+    m_damage = QRegion();
 }
 
 SurfaceBuffer *Surface::createSurfaceBuffer(struct ::wl_resource *buffer)
@@ -419,41 +413,6 @@ SurfaceBuffer *Surface::createSurfaceBuffer(struct ::wl_resource *buffer)
     return newBuffer;
 }
 
-void Surface::attach(struct ::wl_resource *buffer)
-{
-    SurfaceBuffer *last = m_bufferQueue.size()?m_bufferQueue.last():0;
-    if (last) {
-        if (last->waylandBufferHandle() == buffer) {
-            if (QT_WAYLAND_PRINT_BUFFERING_WARNINGS)
-                qWarning() << "attaching already attached buffer";
-            return;
-        }
-        if (!last->damageRect().isValid() || !last->isComitted() || isCursorSurface() ){
-            last->disown();
-            m_bufferQueue.takeLast();
-        }
-    }
-
-    SurfaceBuffer *surfBuf = createSurfaceBuffer(buffer);
-    m_bufferQueue << surfBuf;
-}
-
-void Surface::damage(const QRect &rect)
-{
-    if (m_bufferQueue.empty()) {
-        if (QT_WAYLAND_PRINT_BUFFERING_WARNINGS)
-            qWarning() << "Surface::damage() null buffer";
-        return;
-    }
-    SurfaceBuffer *surfaceBuffer =  m_bufferQueue.last();
-    if (surfaceBuffer->isComitted()) {
-        if (QT_WAYLAND_PRINT_BUFFERING_WARNINGS)
-            qWarning("Surface::damage() on a committed surface");
-    } else{
-        surfaceBuffer->setDamage(rect);
-    }
-}
-
 void Surface::surface_destroy_resource(Resource *)
 {
     compositor()->destroySurface(this);
@@ -466,15 +425,16 @@ void Surface::surface_destroy(Resource *resource)
 
 void Surface::surface_attach(Resource *, struct wl_resource *buffer, int x, int y)
 {
-    Q_UNUSED(x);
-    Q_UNUSED(y);
-
-    attach(buffer);
+    if (m_pending.buffer)
+        m_pending.buffer->disown();
+    m_pending.buffer = createSurfaceBuffer(buffer);
+    m_pending.offset = QPoint(x, y);
+    m_pending.newlyAttached = true;
 }
 
 void Surface::surface_damage(Resource *, int32_t x, int32_t y, int32_t width, int32_t height)
 {
-    damage(QRect(x, y, width, height));
+    m_pending.damage = m_pending.damage.united(QRect(x, y, width, height));
 }
 
 void Surface::surface_frame(Resource *resource, uint32_t callback)
@@ -495,28 +455,27 @@ void Surface::surface_set_input_region(Resource *, struct wl_resource *region)
 
 void Surface::surface_commit(Resource *)
 {
-    if (m_bufferQueue.empty()) {
-        if (QT_WAYLAND_PRINT_BUFFERING_WARNINGS)
-            qWarning("Commit on invalid surface");
-        return;
-    }
+    m_damage = m_pending.damage;
 
-    SurfaceBuffer *surfaceBuffer = m_bufferQueue.last();
-    if (surfaceBuffer->isComitted()) {
-        if (QT_WAYLAND_PRINT_BUFFERING_WARNINGS)
-            qWarning("Committing buffer that has already been committed");
-    } else {
-        surfaceBuffer->setCommitted();
-    }
+    if (m_pending.buffer || m_pending.newlyAttached) {
+        if (m_backBuffer && m_backBuffer != m_pending.buffer)
+            m_backBuffer->disown();
 
-    // A new buffer was added to the queue, so we set it as the current
-    // back buffer. Second and third buffers, if the come, will be handled
-    // in advanceBufferQueue().
-    if (!m_backBuffer && m_bufferQueue.size() == 1) {
-        setBackBuffer(surfaceBuffer);
-        m_bufferQueue.takeFirst();
+        setBackBuffer(m_pending.buffer);
+        if (!m_backBuffer && m_surfaceMapped) {
+            m_surfaceMapped = false;
+            emit m_waylandSurface->unmapped();
+        }
     }
 
+    m_pending.buffer = 0;
+    m_pending.offset = QPoint();
+    m_pending.newlyAttached = false;
+    m_pending.damage = QRegion();
+
+    if (m_backBuffer)
+        m_backBuffer->setCommitted();
+
     m_frameCallbacks << m_pendingFrameCallbacks;
     m_pendingFrameCallbacks.clear();
 }