Merge lp:~cemil-azizoglu/mir/buffer_handle into lp:mir

[Cemil Azizoglu]

Introduce BufferHandle.

[lp:~cemil-azizoglu/mir/buffer_handle]

2415. By Cemil Azizoglu on 2015-03-23

Remove forgotten member

2416. By Cemil Azizoglu on 2015-03-23

whitespace

2417. By Cemil Azizoglu on 2015-03-23

- Move BufferHAndle from mir::compositor to mir::graphics namespace.
- Also Move buffer_handle.cpp under platform.

2418. By Cemil Azizoglu on 2015-03-30

Minimally working implementation.

2419. By Cemil Azizoglu on 2015-03-30

Software cursor

2420. By Cemil Azizoglu on 2015-03-30

touchspot fix

2421. By Cemil Azizoglu on 2015-03-30

Minor fixes

2422. By Cemil Azizoglu on 2015-03-30

merge trunk.

Unmerged revisions

2422. By Cemil Azizoglu on 2015-03-30

merge trunk.

2421. By Cemil Azizoglu on 2015-03-30

Minor fixes

2420. By Cemil Azizoglu on 2015-03-30

touchspot fix

2419. By Cemil Azizoglu on 2015-03-30

Software cursor

2418. By Cemil Azizoglu on 2015-03-30

Minimally working implementation.

2417. By Cemil Azizoglu on 2015-03-23

- Move BufferHAndle from mir::compositor to mir::graphics namespace.
- Also Move buffer_handle.cpp under platform.

2416. By Cemil Azizoglu on 2015-03-23

whitespace

2415. By Cemil Azizoglu on 2015-03-23

Remove forgotten member

2414. By Cemil Azizoglu on 2015-03-23

Add buffer_handle() interface to Renderable.

2413. By Cemil Azizoglu on 2015-03-23

- Remove temporary buffers from the filesystem
- Do away with {compositor|snapshot}_release

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2015-03-30 03:20:27 +0000
+++ examples/render_overlays.cpp	2015-03-30 20:21:06 +0000
@@ -25,6 +25,7 @@
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir_image.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include <chrono>
 #include <csignal>
@@ -33,6 +34,7 @@
 namespace mg=mir::graphics;
 namespace mo=mir::options;
 namespace geom=mir::geometry;
+namespace mc=mir::compositor;
 
 namespace
 {
@@ -142,6 +144,12 @@
         return client->last_rendered();
     }
 
+    mg::BufferHandle buffer_handle() const override
+    {
+    	mg::BufferHandle handle;
+        return handle;
+    }
+
     geom::Rectangle screen_position() const override
     {
         return position;

=== added file 'include/platform/mir/graphics/buffer_handle.h'
--- include/platform/mir/graphics/buffer_handle.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/buffer_handle.h	2015-03-30 20:21:06 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ * Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_BUFFER_HANDLE_H_
+#define MIR_BUFFER_HANDLE_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+
+class Buffer;
+
+typedef std::function<void(Buffer* buffer)> ReleaseCallback;
+
+class BufferHandle
+{
+public:
+    explicit BufferHandle(
+        std::shared_ptr<Buffer> const& buffer,
+        ReleaseCallback const& release);
+
+    BufferHandle(BufferHandle&& other);
+    BufferHandle& operator=(BufferHandle&& other);
+    BufferHandle() = default;
+
+    ~BufferHandle();
+
+    std::shared_ptr<Buffer> buffer();
+    bool operator!();
+
+private:
+    BufferHandle(BufferHandle const&) = delete;
+    BufferHandle& operator=(BufferHandle const&) = delete;
+
+    std::shared_ptr<Buffer> wrapped;
+    ReleaseCallback release_fn;
+};
+
+}
+}
+
+#endif /* MIR_BUFFER_HANDLE_H_*/

=== modified file 'include/platform/mir/graphics/renderable.h'
--- include/platform/mir/graphics/renderable.h	2015-03-30 03:20:27 +0000
+++ include/platform/mir/graphics/renderable.h	2015-03-30 20:21:06 +0000
@@ -26,10 +26,12 @@
 
 namespace mir
 {
+
 namespace graphics
 {
 
 class Buffer;
+class BufferHandle;
 class Renderable
 {
 public:
@@ -48,6 +50,11 @@
      */
     virtual std::shared_ptr<Buffer> buffer() const = 0;
 
+    /**
+     * Return the buffer handle containing the buffer that should be composited/rendered.
+     */
+    virtual BufferHandle buffer_handle() const = 0;
+
     virtual geometry::Rectangle screen_position() const = 0;
 
     // These are from the old CompositingCriteria. There is a little bit

=== modified file 'src/include/server/mir/compositor/buffer_stream.h'
--- src/include/server/mir/compositor/buffer_stream.h	2015-01-21 08:53:28 +0000
+++ src/include/server/mir/compositor/buffer_stream.h	2015-03-30 20:21:06 +0000
@@ -23,6 +23,7 @@
 #include "mir/geometry/size.h"
 #include "mir_toolkit/common.h"
 #include "mir/graphics/buffer_id.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include <memory>
 
@@ -31,6 +32,7 @@
 namespace graphics
 {
 class Buffer;
+class BufferHandle;
 }
 
 namespace compositor
@@ -44,9 +46,8 @@
     virtual void acquire_client_buffer(
         std::function<void(graphics::Buffer* buffer)> complete) = 0;
     virtual void release_client_buffer(graphics::Buffer* buf) = 0;
-    virtual std::shared_ptr<graphics::Buffer>
-        lock_compositor_buffer(void const* user_id) = 0;
-    virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;
+    virtual graphics::BufferHandle lock_compositor_buffer(void const* user_id) = 0;
+    virtual graphics::BufferHandle lock_snapshot_buffer() = 0;
     virtual MirPixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;
     virtual void resize(geometry::Size const& size) = 0;

=== modified file 'src/platform/graphics/CMakeLists.txt'
--- src/platform/graphics/CMakeLists.txt	2015-03-30 03:20:27 +0000
+++ src/platform/graphics/CMakeLists.txt	2015-03-30 20:21:06 +0000
@@ -13,6 +13,7 @@
   gl_texture.cpp
   tessellation_helpers.cpp
   platform_probe.cpp
+  buffer_handle.cpp
 )
 
 add_library(mirplatformgraphicscommon OBJECT

=== added file 'src/platform/graphics/buffer_handle.cpp'
--- src/platform/graphics/buffer_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/buffer_handle.cpp	2015-03-30 20:21:06 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Cemil Azizoglu <[e-mail]>
+ */
+
+#include "mir/graphics/buffer_handle.h"
+
+namespace mg = mir::graphics;
+
+mg::BufferHandle::BufferHandle(std::shared_ptr<mg::Buffer> const& buffer,
+                               ReleaseCallback const& release)
+                               : wrapped(buffer),
+                                 release_fn(release)
+{
+}
+
+mg::BufferHandle::BufferHandle(BufferHandle&& other)
+{
+    *this = std::move(other);
+}
+
+mg::BufferHandle& mg::BufferHandle::operator=(BufferHandle&& other)
+{
+    if (this != &other)
+    {
+        // If the current buffer is being assigned a null handle,
+        // we need to release the buffer.
+    	if (other.wrapped && other.release_fn && release_fn)
+            release_fn(wrapped.get());
+        wrapped = std::move(other.wrapped);
+        release_fn.swap(other.release_fn);
+        // other is emptied out already, prevent double release
+        other.release_fn = nullptr;
+    }
+
+    return *this;
+}
+
+bool mg::BufferHandle::operator!()
+{
+    return (wrapped == nullptr);
+}
+
+mg::BufferHandle::~BufferHandle()
+{
+    if (release_fn)
+        release_fn(wrapped.get());
+}
+
+std::shared_ptr<mg::Buffer> mg::BufferHandle::buffer()
+{
+    return wrapped;
+}

=== modified file 'src/platform/symbols.map'
--- src/platform/symbols.map	2015-03-30 12:29:01 +0000
+++ src/platform/symbols.map	2015-03-30 20:21:06 +0000
@@ -15,6 +15,10 @@
     mir::graphics::Buffer::size*;
     mir::graphics::Buffer::stride*;
     mir::graphics::Buffer::write*;
+    mir::graphics::BufferHandle::BufferHandle*;
+    mir::graphics::BufferHandle::?BufferHandle*;
+    mir::graphics::BufferHandle::buffer*;
+    mir::graphics::BufferHandle::operator*;
     mir::graphics::Cursor::?Cursor*;
     mir::graphics::Cursor::Cursor*;
     mir::graphics::Cursor::hide*;

=== modified file 'src/platforms/mesa/server/display_buffer.cpp'
--- src/platforms/mesa/server/display_buffer.cpp	2015-03-30 03:20:27 +0000
+++ src/platforms/mesa/server/display_buffer.cpp	2015-03-30 20:21:06 +0000
@@ -29,7 +29,8 @@
 
 #include <stdexcept>
 
-namespace mgm = mir::graphics::mesa;
+namespace mg = mir::graphics;
+namespace mgm = mg::mesa;
 namespace geom = mir::geometry;
 
 class mgm::BufferObject
@@ -204,7 +205,8 @@
         auto bypass_it = std::find_if(renderable_list.rbegin(), renderable_list.rend(), bypass_match);
         if (bypass_it != renderable_list.rend())
         {
-            auto bypass_buffer = (*bypass_it)->buffer();
+        	bypass_buffer_handle = (*bypass_it)->buffer_handle();
+            auto bypass_buffer = bypass_buffer_handle.buffer();
             auto native = bypass_buffer->native_buffer_handle();
             auto gbm_native = static_cast<mgm::GBMNativeBuffer*>(native.get());
             auto bufobj = get_buffer_object(gbm_native->bo);
@@ -212,14 +214,13 @@
                 native->flags & mir_buffer_flag_can_scanout &&
                 bypass_buffer->size() == geom::Size{fb_width,fb_height})
             {
-                bypass_buf = bypass_buffer;
                 bypass_bufobj = bufobj;
                 return true;
             }
             else
             {
-                bypass_buf = nullptr;
                 bypass_bufobj = nullptr;
+                bypass_buffer_handle = mg::BufferHandle(nullptr, nullptr);
             }
         }
     }
@@ -237,7 +238,7 @@
 {
     if (!egl.swap_buffers())
         fatal_error("Failed to perform buffer swap");
-    bypass_buf = nullptr;
+    bypass_buffer_handle = mg::BufferHandle(nullptr, nullptr);
     bypass_bufobj = nullptr;
 }
 
@@ -256,7 +257,7 @@
      * we can unreference the bypass buffer...
      */
     if (scheduled_composite_frame)
-        visible_bypass_frame = nullptr;
+        visible_bypass_buffer_handle = mg::BufferHandle(nullptr, nullptr);
     /*
      * Release the last flipped buffer object (which is not displayed anymore)
      * to make it available for future rendering.
@@ -268,16 +269,14 @@
     scheduled_composite_frame = nullptr;
 
     mgm::BufferObject *bufobj;
-    if (bypass_buf)
-    {
-        bufobj = bypass_bufobj;
-    }
-    else
+    if (!bypass_buffer_handle)
     {
         bufobj = get_front_buffer_object();
         if (!bufobj)
             fatal_error("Failed to get front buffer object");
     }
+    else
+        bufobj = bypass_bufobj;
 
     /*
      * Schedule the current front buffer object for display, and wait
@@ -288,7 +287,7 @@
      */
     if (!needs_set_crtc && !schedule_page_flip(bufobj))
     {
-        if (!bypass_buf)
+        if (!bypass_buffer_handle)
             bufobj->release();
         fatal_error("Failed to schedule page flip");
     }
@@ -302,7 +301,36 @@
         needs_set_crtc = false;
     }
 
-    if (bypass_buf)
+    if (!bypass_buffer_handle)
+    {
+        /*
+         * Not in clone mode? We can afford to wait for the page flip then,
+         * making us double-buffered (noticeably less laggy than the triple
+         * buffering that clone mode requires).
+         */
+        if (outputs.size() == 1)
+        {
+            wait_for_page_flip();
+
+            /*
+             * bufobj is now physically on screen. Release the old frame...
+             */
+            if (visible_composite_frame)
+            {
+                visible_composite_frame->release();
+                visible_composite_frame = nullptr;
+            }
+
+            /*
+             * visible_composite_frame will be set correctly on the next iteration
+             * Don't do it here or else bufobj would be released while still
+             * on screen (hence tearing and artefacts).
+             */
+        }
+
+        scheduled_composite_frame = bufobj;
+    }
+    else
     {
         /*
          * For composited frames we defer wait_for_page_flip till just before
@@ -322,36 +350,7 @@
          * the client while its on-screen, which would be seen as tearing or
          * worse.
          */
-        visible_bypass_frame = bypass_buf;
-    }
-    else
-    {
-        /*
-         * Not in clone mode? We can afford to wait for the page flip then,
-         * making us double-buffered (noticeably less laggy than the triple
-         * buffering that clone mode requires).
-         */
-        if (outputs.size() == 1)
-        {
-            wait_for_page_flip();
-
-            /*
-             * bufobj is now physically on screen. Release the old frame...
-             */
-            if (visible_composite_frame)
-            {
-                visible_composite_frame->release();
-                visible_composite_frame = nullptr;
-            }
-
-            /*
-             * visible_composite_frame will be set correctly on the next iteration
-             * Don't do it here or else bufobj would be released while still
-             * on screen (hence tearing and artefacts).
-             */
-        }
-
-        scheduled_composite_frame = bufobj;
+        visible_bypass_buffer_handle = std::move(bypass_buffer_handle);
     }
 }
 

=== modified file 'src/platforms/mesa/server/display_buffer.h'
--- src/platforms/mesa/server/display_buffer.h	2015-03-30 03:20:27 +0000
+++ src/platforms/mesa/server/display_buffer.h	2015-03-30 20:21:06 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/display.h"
 #include "display_helpers.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include <vector>
 #include <memory>
@@ -79,9 +80,9 @@
 
     BufferObject* visible_composite_frame;
     BufferObject* scheduled_composite_frame;
-    std::shared_ptr<graphics::Buffer> visible_bypass_frame;
-    std::shared_ptr<Buffer> bypass_buf{nullptr};
     BufferObject* bypass_bufobj{nullptr};
+    graphics::BufferHandle visible_bypass_buffer_handle{nullptr, nullptr};
+    graphics::BufferHandle bypass_buffer_handle{nullptr, nullptr};
     std::shared_ptr<Platform> const platform;
     std::shared_ptr<DisplayReport> const listener;
     /* DRM helper from mgm::Platform */

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2015-01-21 07:34:50 +0000
+++ src/server/compositor/CMakeLists.txt	2015-03-30 20:21:06 +0000
@@ -3,7 +3,6 @@
 
   default_display_buffer_compositor.cpp
   default_display_buffer_compositor_factory.cpp
-  temporary_buffers.cpp
   buffer_stream_factory.cpp
   buffer_stream_surfaces.cpp
   gl_renderer.cpp

=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2015-01-21 08:53:28 +0000
+++ src/server/compositor/buffer_bundle.h	2015-03-30 20:21:06 +0000
@@ -25,7 +25,7 @@
 
 namespace mir
 {
-namespace graphics { class Buffer; struct BufferProperties; }
+namespace graphics { class Buffer; struct BufferProperties; class BufferHandle; }
 
 namespace compositor
 {
@@ -48,11 +48,8 @@
      *                     collisions, all callers should determine user_id
      *                     in the same way (e.g. always use "this" pointer).
      */
-    virtual std::shared_ptr<graphics::Buffer>
-        compositor_acquire(void const* user_id) = 0;
-    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
-    virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
-    virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;
+    virtual graphics::BufferHandle compositor_acquire(void const* user_id) = 0;
+    virtual graphics::BufferHandle snapshot_acquire() = 0;
 
     virtual graphics::BufferProperties properties() const = 0;
     virtual void allow_framedropping(bool dropping_allowed) = 0;

=== modified file 'src/server/compositor/buffer_queue.cpp'
--- src/server/compositor/buffer_queue.cpp	2015-03-30 03:20:27 +0000
+++ src/server/compositor/buffer_queue.cpp	2015-03-30 20:21:06 +0000
@@ -20,6 +20,7 @@
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/buffer_id.h"
 #include "mir/lockable_callback.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -239,8 +240,7 @@
     ready_to_composite_queue.push_back(buffer);
 }
 
-std::shared_ptr<mg::Buffer>
-mc::BufferQueue::compositor_acquire(void const* user_id)
+mg::BufferHandle mc::BufferQueue::compositor_acquire(void const* user_id)
 {
     std::unique_lock<decltype(guard)> lock(guard);
 
@@ -285,8 +285,30 @@
 
     buffers_sent_to_compositor.push_back(current_compositor_buffer);
 
-    std::shared_ptr<mg::Buffer> const acquired_buffer =
-        buffer_for(current_compositor_buffer, buffers);
+    std::weak_ptr<BufferQueue> weak_this = shared_from_this();
+
+    mg::BufferHandle acquired_buffer(
+        buffer_for(current_compositor_buffer, buffers),
+        [weak_this](mg::Buffer* b)
+        {
+            if (auto self = weak_this.lock())
+            {
+                std::unique_lock<decltype(self->guard)> lock(self->guard);
+
+                remove(b, self->buffers_sent_to_compositor);
+
+                /* Not ready to release it yet, other compositors still reference this buffer */
+                if (contains(b, self->buffers_sent_to_compositor))
+                    return;
+
+                if (self->nbuffers <= 1)
+                    return;
+
+                if (self->current_compositor_buffer != b)
+                    self->release(b, std::move(lock));
+            }
+        });
+
 
     if (buffer_to_release)
         release(buffer_to_release, std::move(lock));
@@ -294,44 +316,26 @@
     return acquired_buffer;
 }
 
-void mc::BufferQueue::compositor_release(std::shared_ptr<graphics::Buffer> const& buffer)
-{
-    std::unique_lock<decltype(guard)> lock(guard);
-
-    if (!remove(buffer.get(), buffers_sent_to_compositor))
-    {
-        BOOST_THROW_EXCEPTION(
-            std::logic_error("unexpected release: buffer was not given to compositor"));
-    }
-
-    /* Not ready to release it yet, other compositors still reference this buffer */
-    if (contains(buffer.get(), buffers_sent_to_compositor))
-        return;
-
-    if (nbuffers <= 1)
-        return;
-
-    if (current_compositor_buffer != buffer.get())
-        release(buffer.get(), std::move(lock));
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferQueue::snapshot_acquire()
+mg::BufferHandle mc::BufferQueue::snapshot_acquire()
 {
     std::unique_lock<decltype(guard)> lock(guard);
     pending_snapshots.push_back(current_compositor_buffer);
-    return buffer_for(current_compositor_buffer, buffers);
-}
-
-void mc::BufferQueue::snapshot_release(std::shared_ptr<graphics::Buffer> const& buffer)
-{
-    std::unique_lock<std::mutex> lock(guard);
-    if (!remove(buffer.get(), pending_snapshots))
-    {
-        BOOST_THROW_EXCEPTION(
-            std::logic_error("unexpected release: no buffers were given to snapshotter"));
-    }
-
-    snapshot_released.notify_all();
+
+    std::weak_ptr<BufferQueue> weak_this = shared_from_this();
+
+    return std::move(mg::BufferHandle(
+               buffer_for(current_compositor_buffer, buffers),
+               [weak_this](mg::Buffer* b)
+               {
+                   if (auto self = weak_this.lock())
+                   {
+                       std::unique_lock<std::mutex> lock(self->guard);
+
+                       remove(b, self->pending_snapshots);
+
+                       self->snapshot_released.notify_all();
+                   }
+               }));
 }
 
 mg::BufferProperties mc::BufferQueue::properties() const

=== modified file 'src/server/compositor/buffer_queue.h'
--- src/server/compositor/buffer_queue.h	2015-03-30 03:20:27 +0000
+++ src/server/compositor/buffer_queue.h	2015-03-30 20:21:06 +0000
@@ -29,15 +29,19 @@
 
 namespace mir
 {
+
 namespace graphics
 {
 class Buffer;
 class GraphicBufferAllocator;
+class BufferHandle;
 }
+
 namespace compositor
 {
 
-class BufferQueue : public BufferBundle
+class BufferQueue : public BufferBundle,
+                    public std::enable_shared_from_this<BufferQueue>
 {
 public:
     typedef std::function<void(graphics::Buffer* buffer)> Callback;
@@ -49,10 +53,8 @@
 
     void client_acquire(Callback complete) override;
     void client_release(graphics::Buffer* buffer) override;
-    std::shared_ptr<graphics::Buffer> compositor_acquire(void const* user_id) override;
-    void compositor_release(std::shared_ptr<graphics::Buffer> const& buffer) override;
-    std::shared_ptr<graphics::Buffer> snapshot_acquire() override;
-    void snapshot_release(std::shared_ptr<graphics::Buffer> const& buffer) override;
+    graphics::BufferHandle compositor_acquire(void const* user_id) override;
+    graphics::BufferHandle snapshot_acquire() override;
 
     graphics::BufferProperties properties() const override;
     void allow_framedropping(bool dropping_allowed) override;

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2015-01-21 08:53:28 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2015-03-30 20:21:06 +0000
@@ -21,8 +21,6 @@
 #include "buffer_bundle.h"
 #include "mir/graphics/buffer_properties.h"
 
-#include "temporary_buffers.h"
-
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
@@ -37,16 +35,15 @@
     force_requests_to_complete();
 }
 
-std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer(
+mg::BufferHandle mc::BufferStreamSurfaces::lock_compositor_buffer(
     void const* user_id)
 {
-    return std::make_shared<mc::TemporaryCompositorBuffer>(
-        buffer_bundle, user_id);
+    return buffer_bundle->compositor_acquire(user_id);
 }
 
-std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_snapshot_buffer()
+mg::BufferHandle mc::BufferStreamSurfaces::lock_snapshot_buffer()
 {
-    return std::make_shared<mc::TemporarySnapshotBuffer>(buffer_bundle);
+    return buffer_bundle->snapshot_acquire();
 }
 
 void mc::BufferStreamSurfaces::acquire_client_buffer(

=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2015-01-21 08:53:28 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2015-03-30 20:21:06 +0000
@@ -26,6 +26,9 @@
 
 namespace mir
 {
+
+namespace graphics { class BufferHandle; }
+
 namespace compositor
 {
 
@@ -42,9 +45,8 @@
     void acquire_client_buffer(std::function<void(graphics::Buffer* buffer)> complete) override;
     void release_client_buffer(graphics::Buffer* buf) override;
 
-    std::shared_ptr<graphics::Buffer>
-        lock_compositor_buffer(void const* user_id) override;
-    std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() override;
+    graphics::BufferHandle lock_compositor_buffer(void const* user_id) override;
+    graphics::BufferHandle lock_snapshot_buffer() override;
 
     MirPixelFormat get_stream_pixel_format() override;
     geometry::Size stream_size() override;

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2015-03-30 03:20:27 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2015-03-30 20:21:06 +0000
@@ -72,11 +72,10 @@
      */
     scene_elements.clear();  // Those in use are still in renderable_list
 
+    report->renderables_in_frame(this, renderable_list);
+
     if (display_buffer.post_renderables_if_optimizable(renderable_list))
-    {
-        report->renderables_in_frame(this, renderable_list);
         renderer->suspend();
-    }
     else
     {
         display_buffer.make_current();
@@ -86,7 +85,6 @@
         renderer->render(renderable_list);
 
         display_buffer.gl_swap_buffers();
-        report->renderables_in_frame(this, renderable_list);
         report->rendered_frame(this);
 
         // Release the buffers we did use back to the clients, before starting

=== removed file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2015-03-30 03:20:27 +0000
+++ src/server/compositor/temporary_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#include "buffer_bundle.h"
-#include "temporary_buffers.h"
-
-#include <boost/throw_exception.hpp>
-#include <stdexcept>
-
-namespace mc=mir::compositor;
-namespace mg=mir::graphics;
-namespace geom=mir::geometry;
-
-mc::TemporaryBuffer::TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer)
-    : buffer(real_buffer)
-{
-}
-
-mc::TemporaryCompositorBuffer::TemporaryCompositorBuffer(
-    std::shared_ptr<BufferBundle> const& bun, void const* user_id)
-    : TemporaryBuffer(bun->compositor_acquire(user_id)),
-      bundle(bun)
-{
-}
-
-mc::TemporaryCompositorBuffer::~TemporaryCompositorBuffer()
-{
-    bundle->compositor_release(buffer);
-}
-
-mc::TemporarySnapshotBuffer::TemporarySnapshotBuffer(
-    std::shared_ptr<BufferBundle> const& bun)
-    : TemporaryBuffer(bun->snapshot_acquire()),
-      bundle(bun)
-{
-}
-
-mc::TemporarySnapshotBuffer::~TemporarySnapshotBuffer()
-{
-    bundle->snapshot_release(buffer);
-}
-
-geom::Size mc::TemporaryBuffer::size() const
-{
-    return buffer->size();
-}
-
-geom::Stride mc::TemporaryBuffer::stride() const
-{
-    return buffer->stride();
-}
-
-MirPixelFormat mc::TemporaryBuffer::pixel_format() const
-{
-    return buffer->pixel_format();
-}
-
-mg::BufferID mc::TemporaryBuffer::id() const
-{
-    return buffer->id();
-}
-
-void mc::TemporaryBuffer::gl_bind_to_texture()
-{
-    buffer->gl_bind_to_texture();
-}
-
-std::shared_ptr<mg::NativeBuffer> mc::TemporaryBuffer::native_buffer_handle() const
-{
-    return buffer->native_buffer_handle();
-}
-
-void mc::TemporaryBuffer::write(unsigned char const*, size_t)
-{
-    BOOST_THROW_EXCEPTION(
-        std::runtime_error("Write to temporary buffer snapshot is ill advised and indicates programmer error"));
-}
-
-void mc::TemporaryBuffer::read(std::function<void(unsigned char const*)> const& exec)
-{
-    buffer->read(exec);
-}

=== removed file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2015-03-30 03:20:27 +0000
+++ src/server/compositor/temporary_buffers.h	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
-#define MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
-
-#include "mir/graphics/buffer.h"
-#include "mir/graphics/buffer_id.h"
-
-namespace mg = mir::graphics;
-
-namespace mir
-{
-namespace compositor
-{
-
-class BufferBundle;
-class BackBufferStrategy;
-
-class TemporaryBuffer : public mg::Buffer
-{
-public:
-    geometry::Size size() const override;
-    geometry::Stride stride() const override;
-    MirPixelFormat pixel_format() const override;
-    mg::BufferID id() const override;
-    void gl_bind_to_texture() override;
-    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override;
-    void write (unsigned char const* data, size_t size) override;
-    void read (std::function<void(unsigned char const*)> const& do_with_pixels) override;
-
-protected:
-    explicit TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer);
-    std::shared_ptr<mg::Buffer> const buffer;
-};
-
-class TemporaryCompositorBuffer : public TemporaryBuffer
-{
-public:
-    explicit TemporaryCompositorBuffer(
-        std::shared_ptr<BufferBundle> const& bun, void const* user_id);
-    ~TemporaryCompositorBuffer();
-
-private:
-    std::shared_ptr<BufferBundle> const bundle;
-};
-
-class TemporarySnapshotBuffer : public TemporaryBuffer
-{
-public:
-    explicit TemporarySnapshotBuffer(
-        std::shared_ptr<BufferBundle> const& bun);
-    ~TemporarySnapshotBuffer();
-
-private:
-    std::shared_ptr<BufferBundle> const bundle;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_ */

=== modified file 'src/server/graphics/software_cursor.cpp'
--- src/server/graphics/software_cursor.cpp	2015-03-30 03:20:27 +0000
+++ src/server/graphics/software_cursor.cpp	2015-03-30 20:21:06 +0000
@@ -23,6 +23,7 @@
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/input/scene.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include <mutex>
 
@@ -71,6 +72,13 @@
         return buffer_;
     }
 
+    mg::BufferHandle buffer_handle() const override
+    {
+        // Not used for software cursor.
+        mg::BufferHandle handle;
+        return handle;
+    }
+
     geom::Rectangle screen_position() const override
     {
         std::lock_guard<std::mutex> lock{position_mutex};

=== modified file 'src/server/input/android/android_pointer_controller.cpp'
--- src/server/input/android/android_pointer_controller.cpp	2015-01-21 07:34:50 +0000
+++ src/server/input/android/android_pointer_controller.cpp	2015-03-30 20:21:06 +0000
@@ -123,11 +123,12 @@
         
         touches.push_back({{x, y}, pressure});
     }
-    
-    touch_visualizer->visualize_touches(touches);
+    if (touch_visualizer)
+        touch_visualizer->visualize_touches(touches);
 }
 
 void mia::PointerController::clearSpots()
 {
-    touch_visualizer->visualize_touches({});
+    if (touch_visualizer)
+        touch_visualizer->visualize_touches({});
 }

=== modified file 'src/server/input/touchspot_controller.cpp'
--- src/server/input/touchspot_controller.cpp	2015-03-30 03:20:27 +0000
+++ src/server/input/touchspot_controller.cpp	2015-03-30 20:21:06 +0000
@@ -26,6 +26,7 @@
 #include "mir/graphics/renderable.h"
 #include "mir/geometry/dimensions.h"
 #include "mir/input/scene.h"
+#include "mir/graphics/buffer_handle.h"
 
 namespace mi = mir::input;
 namespace mg = mir::graphics;
@@ -56,7 +57,13 @@
     {
         return buffer_;
     }
-    
+
+    mg::BufferHandle buffer_handle() const override
+    {
+        mg::BufferHandle handle;
+        return handle;
+    }
+
     geom::Rectangle screen_position() const override
     {
         return {position, buffer_->size()};

=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2015-03-30 03:20:27 +0000
+++ src/server/scene/basic_surface.cpp	2015-03-30 20:21:06 +0000
@@ -27,6 +27,7 @@
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/cursor_image.h"
 #include "mir/geometry/displacement.h"
+#include "mir/graphics/buffer_handle.h"
 
 #include "mir/scene/scene_report.h"
 #include "mir/scene/null_surface_observer.h"
@@ -257,11 +258,6 @@
     surface_buffer_stream->allow_framedropping(allow);
 }
 
-std::shared_ptr<mg::Buffer> ms::BasicSurface::snapshot_buffer() const
-{
-    return surface_buffer_stream->lock_snapshot_buffer();
-}
-
 bool ms::BasicSurface::supports_input() const
 {
     if (server_input_channel  && server_input_channel->client_fd() != -1)
@@ -404,8 +400,8 @@
 void ms::BasicSurface::with_most_recent_buffer_do(
     std::function<void(mg::Buffer&)> const& exec)
 {
-    auto buf = snapshot_buffer();
-    exec(*buf);
+    auto buffer_handle = surface_buffer_stream->lock_snapshot_buffer();
+    exec(*(buffer_handle.buffer()));
 }
 
 
@@ -809,14 +805,13 @@
         bool shaped,
         mg::Renderable::ID id)
     : underlying_buffer_stream{stream},
-      compositor_buffer{nullptr},
+      buffer_handle_handed_out(false),
       compositor_id{compositor_id},
       alpha_{alpha},
       shaped_{shaped},
       screen_position_(position),
       transformation_(transform),
-      id_(id)
-    {
+      id_(id)    {
     }
 
     ~SurfaceSnapshot()
@@ -825,9 +820,27 @@
  
     std::shared_ptr<mg::Buffer> buffer() const override
     {
-        if (!compositor_buffer)
-            compositor_buffer = underlying_buffer_stream->lock_compositor_buffer(compositor_id);
-        return compositor_buffer;
+        if (buffer_handle_handed_out)
+        {
+            // Once buffer_handle() is called, the buffer is managed elsewhere
+            BOOST_THROW_EXCEPTION(
+                std::runtime_error("Calling buffer() after buffer_handle() is called is not allowed"));
+            return nullptr;
+        }
+        else
+        {
+            if (!compositor_buffer_handle)
+                compositor_buffer_handle = underlying_buffer_stream->lock_compositor_buffer(compositor_id);
+        }
+        return compositor_buffer_handle.buffer();
+    }
+
+    mg::BufferHandle buffer_handle() const override
+    {
+        if (!compositor_buffer_handle)
+            compositor_buffer_handle = underlying_buffer_stream->lock_compositor_buffer(compositor_id);
+        buffer_handle_handed_out = true;
+        return std::move(compositor_buffer_handle);
     }
 
     geom::Rectangle screen_position() const override
@@ -846,7 +859,8 @@
     { return id_; }
 private:
     std::shared_ptr<mc::BufferStream> const underlying_buffer_stream;
-    std::shared_ptr<mg::Buffer> mutable compositor_buffer;
+    mg::BufferHandle mutable compositor_buffer_handle;
+    bool mutable buffer_handle_handed_out;
     void const*const compositor_id;
     float const alpha_;
     bool const shaped_;

=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2015-03-30 03:20:27 +0000
+++ src/server/scene/basic_surface.h	2015-03-30 20:21:06 +0000
@@ -113,7 +113,6 @@
 
     MirPixelFormat pixel_format() const override;
 
-    std::shared_ptr<graphics::Buffer> snapshot_buffer() const;
     void swap_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) override;
     void force_requests_to_complete() override;