Merge lp:~cemil-azizoglu/mir/improve-raii into lp:mir

[Cemil Azizoglu]

Improve raii in the way compositor and snapshot buffers are handled in the buffer queue.

Improve raii in buffer queue, which results in doing away with TemporaryBuffer and BufferStream (server-side) classes (at the cost of introducing a small BufferHandle class). Also BufferStreamFactory is now BufferQueueFactory.

The BufferBundle (and hence the BufferQueue) interface has been simplified due to the fact that now buffers are returned to the queue as part of BufferHandle destructor and not via an explicit call. This simplifies error handling during buffer releases.

Also, temporary buffers inheriting from Buffer is avoided, since they no longer exist. (This previously prevented Buffer being cast as the correct platform buffer type, though we found a different way to handle that case).

The heart of this MP lies in buffer_queue.cpp. For review purposes, one should start from compositor_acquire/snapshot_acquire functions and fan out from there.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2343
http://jenkins.qa.ubuntu.com/job/mir-ci/3094/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1456
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1455
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1410
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1091
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1091/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1410
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1410/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4432
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18437

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

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

Seems like (more or less) an even trade-off to me as to what we had before.
typing:
auto b = bundle->compositor_acquire(...);
b->buffer()->methods();
saves on having to update the Temporary*Buffer adapter objects, but is more awkward to type, compared to:
auto b = bundle->compositor_acquire(...);
b->methods();

84 +mc::BufferHandle::BufferHandle(BufferBundle* bundle,
We used to preserve ownership of the BufferBundle in the temporary buffers, seems like something that could cause problems around the client's destruction if we don't have BufferBundle ownership, and are trying to return in the destructor of BufferHandle.

169 + explicit CompositorBufferHandle(BufferBundle* bundle,
177 + explicit SnapshotBufferHandle(BufferBundle* bundle,
spacing

161 + std::shared_ptr<graphics::Buffer> buffer);
170 + std::shared_ptr<graphics::Buffer> buffer);
178 + std::shared_ptr<graphics::Buffer> buffer);
const&

We already have a "native handle", might be over-using the word "Handle" in mc::BufferHandle. (I'm mostly just trying to avoid writing: mg::BufferHandle handle{...}; handle->buffer()->native_buffer_handle() )

257 + std::shared_ptr<mc::BufferHandle> const acquired_buffer =
258 + std::make_shared<mc::SnapshotBufferHandle>(this, buffer_for(current_compositor_buffer, buffers));
259 +
260 + return acquired_buffer;
could just:
return std::make_shared<mc::SnapshotBufferHandle(...)

review: Needs Fixing

[Alberto Aguirre (albaguirre)]

===
48 + virtual std::shared_ptr<BufferHandle> compositor_acquire(void const* user_id) = 0;
49 + virtual void compositor_release(graphics::Buffer* const buffer) = 0;
50 + virtual std::shared_ptr<BufferHandle> snapshot_acquire() = 0;
51 + virtual void snapshot_release(graphics::Buffer* const buffer) = 0;
==

I'd rather have compositor_acquire and snapshot_acquire return a BufferHandle by value.
BufferHandle should be a moveable only type.

The BufferHandle constructor could also be:

BufferHande(std::function<void()> const& release)

Then we can remove compositor_release and snapshot_release.

===
334 + return buffer_bundle->compositor_acquire(user_id)->buffer();
===

Nobody is holding the return shared_ptr<BufferHandle> so at the end of this scope, the buffer will be returned to the queue - possibly resulting in tearing artifacts.

In order for this to work correctly the caller of lock_compositor_buffer (i.e. SurfaceSnapshot) needs to be able to receive the BufferHandle object. That would pretty much make BufferStream a useless replicated interface - they should all just collapse to BufferBundle instead.

===
160 + explicit BufferHandle(BufferBundle* bundle,
161 + std::shared_ptr<graphics::Buffer> buffer);
162 + BufferBundle* buffer_bundle;
===

As mentioned above this could probably be:

class BufferHandle
{
public:
    typedef std::function<void(graphics::Buffer* buffer)> Callback;
    explicit BufferHandle(std::shared_ptr<graphics::Buffer> const& buffer,
                          Callback const& release);

    //Move constructor
    BufferHandle(BufferHandle&& other);
    //Move assignment
    BufferHandle& operator=(BufferHandle&& other);

    std::shared_ptr<graphics::Buffer> buffer();

private:
    // Moveable only type
    BufferHandle(BufferHandle const&) = delete;
    BufferHandle& operator=(BufferHandle const&) = delete;

    std::shared_ptr<graphics::Buffer> wrapped;
    Callback release;
};

===
213 + std::shared_ptr<mc::BufferHandle> const acquired_buffer =
214 + std::make_shared<mc::CompositorBufferHandle>(this, buffer_for(current_compositor_buffer, buffers));
===

With the BufferHandle above then this would become:

BufferHandle const handle{buffer_for(current_compositor_buffer, buffers),
 [weak_ptr_this](Buffer* buffer)
 {
    if (auto self = weak_ptr_this.lock())
    {
       compositor_release(buffer);
    }
 }

The weak_ptr_this is needed to ensure you won't be calling dead code if the BufferQueue gets destroyed before one of the BufferHandles. Alternatively, you could keep a shared_ptr instead to keep the buffer queue object alive but I would prefer the BufferHandle to not impose that requirement.

The above will require enabled_shared_from_this support in the BufferQueue class.

review: Needs Fixing

[Cemil Azizoglu (cemil-azizoglu)]

@Alberto, @Kevin, your comments should have been addressed.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2374
http://jenkins.qa.ubuntu.com/job/mir-ci/3237/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1666/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1665
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1620/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1234
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1234/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1620/console

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

review: Needs Fixing (continuous-integration)

[lp:~cemil-azizoglu/mir/improve-raii]

2375. By Cemil Azizoglu on 2015-03-17

Fix Android.

[Daniel van Vugt (vanvugt)]

I knew this was coming. And by numbers I like the simplification. But the fact that some of our most sensitive test cases are being rewritten en-masse scares me. We'll all need to do some careful manual testing of this.

review: Abstain

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2375
http://jenkins.qa.ubuntu.com/job/mir-ci/3238/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1667
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1666
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1621
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1235
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1235/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1621
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1621/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4632
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18895

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

2993 + ASSERT_NO_THROW(q = std::shared_ptr<mc::BufferQueue>(
2994 + new mc::BufferQueue(nbuffers, allocator, basic_properties, policy_factory)));

Here and elsewhere, better with std::make_shared<>

review: Needs Fixing

[lp:~cemil-azizoglu/mir/improve-raii]

2376. By Cemil Azizoglu on 2015-03-17

Use make_shared.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2376
http://jenkins.qa.ubuntu.com/job/mir-ci/3252/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1681
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1680
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1635
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1249
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1249/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1635
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1635/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4644
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18918

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

review: Approve (continuous-integration)

[Alberto Aguirre (albaguirre)]

===
68 +typedef std::function<void(graphics::Buffer* buffer)> release_callback;
===

Should be ReleaseCallback according to the mir style guide:
http://unity.ubuntu.com/mir/cppguide/index.html#Type_Names

===
80 + virtual ~BufferHandle();
===

Not needed

===
356 + if (release_fn)
357 + release_fn(wrapped.get());
===
I think Move assignment should not cause the buffer to be released back to the queue.
That would be analogous to move assigning a unique_ptr and having the ptr be deleted while doing that.

===
1198 + compositor_buffer_handle{nullptr, nullptr},
1209 + if (!compositor_buffer_handle.buffer())
1210 + compositor_buffer_handle = underlying_buffer_queue->compositor_acquire(compositor_id);
===

Maybe a bit cleaner (but not blocking) if you allow BufferHandle to be default constructed and implement the negation operator,
so that line 1198 is not needed then, and line 1209 just becomes: if (!compositor_buffer_handle)

===
1623 + return std::move(compositor::BufferHandle(stub_compositor_buffer, nullptr));
1628 + return std::move(compositor::BufferHandle(stub_compositor_buffer, nullptr));
===

You ca do away with the std::move

Needs information:

Do the BufferStream integration and unit tests (BufferStreamTest.*) overlap with other tests?
Otherwise they should be updated but kept not removed.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

(1) Regression: Did some quick manual testing. Fullscreen bypassed surfaces are visibly tearing when using this branch...
   mir_demo_client_egltriangle -f
   mir_demo_client_eglplasma

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

This is what happens when we rewrite test cases en-masse. Regression tests stop protecting us from regressions.

[Daniel van Vugt (vanvugt)]

Or for even more tearing, try:
  mir_demo_client_egltriangle -f -n

[Alexandros Frantzis (afrantzis)]

348 + release_fn(std::move(other.release_fn))
367 + if (release_fn)

Unfortunately the standard says that move-constructing a std::function from another std::function leaves the latter in a valid but unspecified state. So "if (release_fn)" in the destructor is not guaranteed to be false after the move. We could use "if (wrapped && release_fn)" instead, since std::shared_ptr provides the guarantee we need.

Also note that after we remove (as mentioned by Alberto above):

356 + if (release_fn)
357 + release_fn(wrapped.get());

we could use the default implementations of move-construct and move-assign methods (we would need to explicitly define them with "= default");

review: Needs Fixing

[Alberto Aguirre (albaguirre)]

> 348 + release_fn(std::move(other.release_fn))
> 367 + if (release_fn)
>
> Unfortunately the standard says that move-constructing a std::function from
> another std::function leaves the latter in a valid but unspecified state. So
> "if (release_fn)" in the destructor is not guaranteed to be false after the
> move.

That's so weird. I guess you could use other.swap(release_fn) in the constructor body instead. I hope that's well defined :)

[lp:~cemil-azizoglu/mir/improve-raii]

2377. By Cemil Azizoglu on 2015-03-18

Fixes for review feedback.

[Cemil Azizoglu (cemil-azizoglu)]

@Alberto, Alexandros, thanks. Should be fixed now.

@Alberto, I have yet to check if we have overlapping buffer stream tests.

@Daniel, thanks for testing. I cannot see tearing in

mir_demo_client_egltriangle -f
mir_demo_client_eglplasma

I see tearing and general corruption when I run
mir_demo_client_egltriangle -f -n
However, when I run this on the trunk, the triangle moves once every second or so. Is this what youre seeing? And doesn't -n mean don't wait for vsync, so isn't tearing expected?

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2377
http://jenkins.qa.ubuntu.com/job/mir-ci/3273/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1706
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1705
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1660/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1270/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1660/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Cemil,

You're using radeon still right? In that case the "once every second or so" is sadly expected. See bug 1211700. Seems only intel has the ability to unthrottle rendering without starving the server process of GPU time. radeon and nouveau are not so good at fair scheduling the GPU. IIRC, proprietary drivers have no such problems. So I guess don't use the "-n" option on your machine. Still, tearing is obviously wrong.

[Daniel van Vugt (vanvugt)]

BTW, bypass is weird. And I think kdub's overlay logic requires the same approach.

To avoid tearing the compositor has to briefly hold both (at least 2) of the client's buffers so as to retain the guarantee for the scan-out hardware that whatever is on-screen is not touched by the client till something else is definitely on screen.

// buffer B is on screen
acquire buffer A
scan out buffer A
release buffer B (to the client)
wait for vblank // allows client almost 16ms to render new B
acquire buffer B
scan out buffer B
release buffer A (to the client)
wait for vblank // allows client almost 16ms to render new A
acquire buffer A
scan out buffer A
release buffer B

That's for normal bypass/overlays. If you use "-n" then framedropping mode forces the BufferQueue to have at least 3 buffers {A,B,C}. So the screen can't ever be starved of the newest frame by an unthrottled client (that issue applies to all compositing, not just bypass). But we always guarantee that and that's not the (radeon) bug you're seeing.

[lp:~cemil-azizoglu/mir/improve-raii]

2378. By Cemil Azizoglu on 2015-03-19

Address CI failures.

[Kevin DuBois (kdub)]

> This is what happens when we rewrite test cases en-masse. Regression tests
> stop protecting us from regressions.

+1, and the tests that have been rewritten are some of the most carefully written to avoid sensitive problems. We haven't had a tearing regression in quite a while (12+ months), so changing so much core testing and swapping code makes me nervous, especially because tearing is a very public regression that everyone tends to notice.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2378
http://jenkins.qa.ubuntu.com/job/mir-ci/3281/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1715
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1714
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1669
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1278
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1278/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1669
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1669/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4671
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18996

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

review: Approve (continuous-integration)

[Alberto Aguirre (albaguirre)]

===
360 + release_fn = std::move(other.release_fn);
===

This has a similar issue:

From http://www.cplusplus.com/reference/functional/function/operator=/
"
(2) move assignment
The object acquires the target of rhs.
rhs is left in an unspecified but valid state.
"

The tearing occurs in bypass (or overlays with android) because the implementation of post_renderables_if_optimizable in mesa and android keep a copy of the shared_ptr<Buffer> to guarantee it wouldn't be released to the client. This has changed now, as holding a reference to the buffer no longer implies the same behavior. Some rework is needed there (which I think it's good, because we should avoid nebulous ownership semantics)

review: Needs Fixing

[Kevin DuBois (kdub)]

> implies the same behavior. Some rework is needed there (which I think it's
> good, because we should avoid nebulous ownership semantics)

I don't think the current semantics are nebulous. The TemporaryBuffers are a Buffer resource; they're a guarantee that they have a buffer locked for a particular purpose for a period of time. Likewise the {mgm/mga}::Buffers are a Buffer resource too, but they have the lifetime of the allocation we request from the driver.

[Kevin DuBois (kdub)]

>
> > implies the same behavior. Some rework is needed there (which I think it's
> > good, because we should avoid nebulous ownership semantics)
>
> I don't think the current semantics are nebulous. The TemporaryBuffers are a
> Buffer resource; they're a guarantee that they have a buffer locked for a
> particular purpose for a period of time. Likewise the {mgm/mga}::Buffers are a
> Buffer resource too, but they have the lifetime of the allocation we request
> from the driver.

Furthermore, from mg::Display::post_renderables_if_optimizable()'s perspective, the buffers that are sent there don't even have to be associated with the BufferQueue stuff. We'll hit problems with the cursor (and, in ~kdub/mir/demo-titlebar, the decorations), if we start requiring that the resource passed to the 2d optimized function is sourced from the BufferQueues.

[lp:~cemil-azizoglu/mir/improve-raii]

2379. By Cemil Azizoglu on 2015-03-19

Do away with unnecessary std::move()

2380. By Cemil Azizoglu on 2015-03-20

Fix another case of std::move(std::function()).

Unmerged revisions

2380. By Cemil Azizoglu on 2015-03-20

Fix another case of std::move(std::function()).

2379. By Cemil Azizoglu on 2015-03-19

Do away with unnecessary std::move()

2378. By Cemil Azizoglu on 2015-03-19

Address CI failures.

2377. By Cemil Azizoglu on 2015-03-18

Fixes for review feedback.

2376. By Cemil Azizoglu on 2015-03-17

Use make_shared.

2375. By Cemil Azizoglu on 2015-03-17

Fix Android.

2374. By Cemil Azizoglu on 2015-03-16

Add BufferHandle test.

2373. By Cemil Azizoglu on 2015-03-16

Fix test properly.

2372. By Cemil Azizoglu on 2015-03-16

Fix a test.

2371. By Cemil Azizoglu on 2015-03-16

Merge trunk

=== renamed file 'src/server/compositor/buffer_bundle.h' => 'src/include/server/mir/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2015-01-21 08:53:28 +0000
+++ src/include/server/mir/compositor/buffer_bundle.h	2015-03-20 19:31:52 +0000
@@ -29,6 +29,7 @@
 
 namespace compositor
 {
+class BufferHandle;
 
 class BufferBundle
 {
@@ -48,16 +49,14 @@
      *                     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 BufferHandle compositor_acquire(void const* user_id) = 0;
+    virtual BufferHandle snapshot_acquire() = 0;
 
     virtual graphics::BufferProperties properties() const = 0;
     virtual void allow_framedropping(bool dropping_allowed) = 0;
     virtual void force_requests_to_complete() = 0;
     virtual void resize(const geometry::Size &newsize) = 0;
+    virtual geometry::Size size() const = 0;
     virtual int buffers_ready_for_compositor(void const* user_id) const = 0;
 
     /**
 
=== added file 'src/include/server/mir/compositor/buffer_handle.h'
--- src/include/server/mir/compositor/buffer_handle.h	1970-01-01 00:00:00 +0000
+++ src/include/server/mir/compositor/buffer_handle.h	2015-03-20 19:31:52 +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; }
+
+namespace compositor
+{
+
+typedef std::function<void(graphics::Buffer* buffer)> ReleaseCallback;
+
+class BufferHandle
+{
+public:
+    explicit BufferHandle(
+        std::shared_ptr<graphics::Buffer> const& buffer,
+        ReleaseCallback const& release);
+
+    BufferHandle(BufferHandle&& other);
+    BufferHandle& operator=(BufferHandle&& other);
+    BufferHandle() = default;
+
+    ~BufferHandle();
+
+    std::shared_ptr<graphics::Buffer> buffer();
+    bool operator!();
+
+private:
+    BufferHandle(BufferHandle const&) = delete;
+    BufferHandle& operator=(BufferHandle const&) = delete;
+
+    std::shared_ptr<graphics::Buffer> wrapped;
+    ReleaseCallback release_fn;
+};
+
+}
+}
+
+#endif /* MIR_BUFFER_HANDLE_H_*/
 
=== renamed file 'src/server/compositor/buffer_queue.h' => 'src/include/server/mir/compositor/buffer_queue.h'
--- src/server/compositor/buffer_queue.h	2015-03-06 03:52:41 +0000
+++ src/include/server/mir/compositor/buffer_queue.h	2015-03-20 19:31:52 +0000
@@ -37,7 +37,10 @@
 namespace compositor
 {
 
-class BufferQueue : public BufferBundle
+class BufferHandle;
+
+class BufferQueue : public BufferBundle,
+                    public std::enable_shared_from_this<BufferQueue>
 {
 public:
     typedef std::function<void(graphics::Buffer* buffer)> Callback;
@@ -49,15 +52,14 @@
 
     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;
+    BufferHandle compositor_acquire(void const* user_id) override;
+    BufferHandle snapshot_acquire() override;
 
     graphics::BufferProperties properties() const override;
     void allow_framedropping(bool dropping_allowed) override;
     void force_requests_to_complete() override;
     void resize(const geometry::Size &newsize) override;
+    geometry::Size size() const override;
     int buffers_ready_for_compositor(void const* user_id) const override;
     int buffers_free_for_client() const override;
     bool framedropping_allowed() const;
 
=== removed 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	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright © 2012-2014 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_BUFFER_STREAM_H_
-#define MIR_COMPOSITOR_BUFFER_STREAM_H_
-
-#include "mir/geometry/size.h"
-#include "mir_toolkit/common.h"
-#include "mir/graphics/buffer_id.h"
-
-#include <memory>
-
-namespace mir
-{
-namespace graphics
-{
-class Buffer;
-}
-
-namespace compositor
-{
-
-class BufferStream
-{
-public:
-    virtual ~BufferStream() = default;
-
-    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 MirPixelFormat get_stream_pixel_format() = 0;
-    virtual geometry::Size stream_size() = 0;
-    virtual void resize(geometry::Size const& size) = 0;
-    virtual void allow_framedropping(bool) = 0;
-    virtual void force_requests_to_complete() = 0;
-    virtual int buffers_ready_for_compositor(void const* user_id) const = 0;
-    virtual void drop_old_buffers() = 0;
-    virtual void drop_client_requests() = 0;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_STREAM_H_ */
 
=== modified file 'src/include/server/mir/default_server_configuration.h'
--- src/include/server/mir/default_server_configuration.h	2015-03-06 03:52:41 +0000
+++ src/include/server/mir/default_server_configuration.h	2015-03-20 19:31:52 +0000
@@ -45,7 +45,7 @@
 namespace compositor
 {
 class Renderer;
-class BufferStreamFactory;
+class BufferQueueFactory;
 class Scene;
 class Drawer;
 class DisplayBufferCompositorFactory;
@@ -87,7 +87,7 @@
 {
 class SurfaceFactory;
 class BroadcastingSessionEventSink;
-class BufferStreamFactory;
+class BufferQueueFactory;
 class MediatingDisplayChanger;
 class PixelBuffer;
 class PlacementStrategy;
@@ -278,7 +278,7 @@
     /** @name scene configuration - dependencies
      * dependencies of scene on the rest of the Mir
      *  @{ */
-    virtual std::shared_ptr<scene::BufferStreamFactory> the_buffer_stream_factory();
+    virtual std::shared_ptr<scene::BufferQueueFactory> the_buffer_queue_factory();
     virtual std::shared_ptr<scene::SceneReport>      the_scene_report();
     /** @} */
 
@@ -389,7 +389,7 @@
     CachedPtr<frontend::ConnectionCreator> prompt_connection_creator;
     CachedPtr<frontend::Screencast> screencast;
     CachedPtr<compositor::RendererFactory> renderer_factory;
-    CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
+    CachedPtr<compositor::BufferQueueFactory> buffer_queue_factory;
     CachedPtr<compositor::FrameDroppingPolicyFactory> frame_dropping_policy_factory;
     CachedPtr<scene::SurfaceStack> surface_stack;
     CachedPtr<scene::SceneReport> scene_report;
 
=== renamed file 'src/include/server/mir/scene/buffer_stream_factory.h' => 'src/include/server/mir/scene/buffer_queue_factory.h'
--- src/include/server/mir/scene/buffer_stream_factory.h	2015-03-16 03:39:55 +0000
+++ src/include/server/mir/scene/buffer_queue_factory.h	2015-03-20 19:31:52 +0000
@@ -18,33 +18,33 @@
  *  Thomas Voss <[e-mail]>
  */
 
-#ifndef MIR_SCENE_BUFFER_STREAM_FACTORY_H_
-#define MIR_SCENE_BUFFER_STREAM_FACTORY_H_
+#ifndef MIR_SCENE_BUFFER_QUEUE_FACTORY_H_
+#define MIR_SCENE_BUFFER_QUEUE_FACTORY_H_
 
 #include <memory>
 
 namespace mir
 {
-namespace compositor { class BufferStream; }
+namespace compositor { class BufferBundle; }
 namespace graphics { struct BufferProperties; }
 
 namespace scene
 {
-class BufferStreamFactory
+class BufferQueueFactory
 {
 public:
-    virtual ~BufferStreamFactory() = default;
+    virtual ~BufferQueueFactory() = default;
 
-    virtual std::shared_ptr<compositor::BufferStream> create_buffer_stream(
-        int nbuffers, graphics::BufferProperties const& buffer_properties) = 0;
+    virtual std::shared_ptr<compositor::BufferBundle> create_buffer_queue(
+            int nbuffers, graphics::BufferProperties const& buffer_properties) = 0;
 
 protected:
-    BufferStreamFactory() = default;
-    BufferStreamFactory(const BufferStreamFactory&) = delete;
-    BufferStreamFactory& operator=(const BufferStreamFactory&) = delete;
+    BufferQueueFactory() = default;
+    BufferQueueFactory(const BufferQueueFactory&) = delete;
+    BufferQueueFactory& operator=(const BufferQueueFactory&) = delete;
 };
 
 }
 }
 
-#endif // MIR_SCENE_BUFFER_STREAM_FACTORY_H_
+#endif // MIR_SCENE_BUFFER_QUEUE_FACTORY_H_
 
=== 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-20 19:31:52 +0000
@@ -3,9 +3,7 @@
 
   default_display_buffer_compositor.cpp
   default_display_buffer_compositor_factory.cpp
-  temporary_buffers.cpp
-  buffer_stream_factory.cpp
-  buffer_stream_surfaces.cpp
+  buffer_queue_factory.cpp
   gl_renderer.cpp
   gl_renderer_factory.cpp
   gl_program_family.cpp
@@ -16,6 +14,7 @@
   compositing_screencast.cpp
   timeout_frame_dropping_policy_factory.cpp
   buffer_queue.cpp
+  buffer_handle.cpp
   recently_used_cache.cpp
 )
 
 
=== added file 'src/server/compositor/buffer_handle.cpp'
--- src/server/compositor/buffer_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/server/compositor/buffer_handle.cpp	2015-03-20 19:31:52 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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/compositor/buffer_handle.h"
+
+namespace mc = mir::compositor;
+namespace mg = mir::graphics;
+
+mc::BufferHandle::BufferHandle(std::shared_ptr<mg::Buffer> const& buffer,
+                               ReleaseCallback const& release)
+                               : wrapped(buffer),
+                                 release_fn(release)
+{
+}
+
+mc::BufferHandle::BufferHandle(BufferHandle&& other)
+                               : wrapped(std::move(other.wrapped))
+{
+    // We can't std:move a std::function as it leaves the "other" unspecified
+    release_fn.swap(other.release_fn);
+}
+
+mc::BufferHandle& mc::BufferHandle::operator=(BufferHandle&& other)
+{
+    if (this != &other)
+    {
+        wrapped = std::move(other.wrapped);
+        release_fn.swap(other.release_fn);
+    }
+
+    return *this;
+}
+
+bool mc::BufferHandle::operator!()
+{
+    return (wrapped == nullptr);
+}
+
+mc::BufferHandle::~BufferHandle()
+{
+    if (release_fn)
+        release_fn(wrapped.get());
+}
+
+std::shared_ptr<mg::Buffer> mc::BufferHandle::buffer()
+{
+    return wrapped;
+}
 
=== modified file 'src/server/compositor/buffer_queue.cpp'
--- src/server/compositor/buffer_queue.cpp	2015-03-06 03:52:41 +0000
+++ src/server/compositor/buffer_queue.cpp	2015-03-20 19:31:52 +0000
@@ -15,10 +15,11 @@
  *
  */
 
-#include "buffer_queue.h"
+#include "mir/compositor/buffer_queue.h"
 
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/buffer_id.h"
+#include "mir/compositor/buffer_handle.h"
 #include "mir/lockable_callback.h"
 
 #include <boost/throw_exception.hpp>
@@ -28,6 +29,7 @@
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
+namespace geom = mir::geometry;
 
 namespace
 {
@@ -239,8 +241,7 @@
     ready_to_composite_queue.push_back(buffer);
 }
 
-std::shared_ptr<mg::Buffer>
-mc::BufferQueue::compositor_acquire(void const* user_id)
+mc::BufferHandle mc::BufferQueue::compositor_acquire(void const* user_id)
 {
     std::unique_lock<decltype(guard)> lock(guard);
 
@@ -285,53 +286,56 @@
 
     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();
+
+    mc::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));
 
-    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()
+    return std::move(acquired_buffer);
+}
+
+mc::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(mc::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
@@ -367,6 +371,11 @@
     }
 }
 
+geom::Size mc::BufferQueue::size() const
+{
+    return properties().size;
+}
+
 void mc::BufferQueue::resize(geometry::Size const& new_size)
 {
     std::lock_guard<decltype(guard)> lock(guard);
 
=== renamed file 'src/server/compositor/buffer_stream_factory.cpp' => 'src/server/compositor/buffer_queue_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2015-03-16 03:39:55 +0000
+++ src/server/compositor/buffer_queue_factory.cpp	2015-03-20 19:31:52 +0000
@@ -18,10 +18,9 @@
  *   Thomas Voss <[e-mail]>
  */
 
-#include "buffer_stream_factory.h"
-#include "buffer_stream_surfaces.h"
+#include "buffer_queue_factory.h"
 #include "mir/graphics/buffer_properties.h"
-#include "buffer_queue.h"
+#include "mir/compositor/buffer_queue.h"
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
@@ -32,10 +31,9 @@
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
-namespace ms = mir::scene;
 
-mc::BufferStreamFactory::BufferStreamFactory(std::shared_ptr<mg::GraphicBufferAllocator> const& gralloc,
-                                             std::shared_ptr<mc::FrameDroppingPolicyFactory> const& policy_factory)
+mc::BufferQueueFactory::BufferQueueFactory(std::shared_ptr<mg::GraphicBufferAllocator> const& gralloc,
+                                           std::shared_ptr<mc::FrameDroppingPolicyFactory> const& policy_factory)
         : gralloc(gralloc),
           policy_factory{policy_factory}
 {
@@ -43,11 +41,8 @@
     assert(policy_factory);
 }
 
-
-std::shared_ptr<mc::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
-    int nbuffers, mg::BufferProperties const& buffer_properties)
+std::shared_ptr<mc::BufferBundle> mc::BufferQueueFactory::create_buffer_queue(
+		int nbuffers, mg::BufferProperties const& buffer_properties)
 {
-    auto switching_bundle = std::make_shared<mc::BufferQueue>(
-        nbuffers, gralloc, buffer_properties, *policy_factory);
-    return std::make_shared<mc::BufferStreamSurfaces>(switching_bundle);
+    return std::make_shared<mc::BufferQueue>(nbuffers, gralloc, buffer_properties, *policy_factory);
 }
 
=== renamed file 'src/server/compositor/buffer_stream_factory.h' => 'src/server/compositor/buffer_queue_factory.h'
--- src/server/compositor/buffer_stream_factory.h	2015-03-16 03:39:55 +0000
+++ src/server/compositor/buffer_queue_factory.h	2015-03-20 19:31:52 +0000
@@ -18,10 +18,10 @@
  *  Thomas Voss <[e-mail]>
  */
 
-#ifndef MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_
-#define MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_
+#ifndef MIR_COMPOSITOR_BUFFER_QUEUE_FACTORY_H_
+#define MIR_COMPOSITOR_BUFFER_QUEUE_FACTORY_H_
 
-#include "mir/scene/buffer_stream_factory.h"
+#include "mir/scene/buffer_queue_factory.h"
 #include "mir/compositor/frame_dropping_policy_factory.h"
 
 #include <memory>
@@ -35,16 +35,16 @@
 namespace compositor
 {
 
-class BufferStreamFactory : public scene::BufferStreamFactory
+class BufferQueueFactory : public scene::BufferQueueFactory
 {
 public:
-    BufferStreamFactory(std::shared_ptr<graphics::GraphicBufferAllocator> const& gralloc,
-                        std::shared_ptr<FrameDroppingPolicyFactory> const& policy_factory);
-
-    virtual ~BufferStreamFactory() {}
-
-    virtual std::shared_ptr<BufferStream> create_buffer_stream(
-        int nbuffers, graphics::BufferProperties const&) override;
+    BufferQueueFactory(std::shared_ptr<graphics::GraphicBufferAllocator> const& gralloc,
+                       std::shared_ptr<FrameDroppingPolicyFactory> const& policy_factory);
+
+    virtual ~BufferQueueFactory() {}
+
+    virtual std::shared_ptr<BufferBundle> create_buffer_queue(
+        int nbuffers, graphics::BufferProperties const& buffer_properties) override;
 
 private:
     std::shared_ptr<graphics::GraphicBufferAllocator> gralloc;
@@ -55,4 +55,4 @@
 }
 
 
-#endif /* MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_ */
+#endif /* MIR_COMPOSITOR_BUFFER_QUEUE_FACTORY_H_ */
 
=== removed 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	1970-01-01 00:00:00 +0000
@@ -1,101 +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_stream_surfaces.h"
-#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;
-
-mc::BufferStreamSurfaces::BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& buffer_bundle)
-    : buffer_bundle(buffer_bundle)
-{
-}
-
-mc::BufferStreamSurfaces::~BufferStreamSurfaces()
-{
-    force_requests_to_complete();
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer(
-    void const* user_id)
-{
-    return std::make_shared<mc::TemporaryCompositorBuffer>(
-        buffer_bundle, user_id);
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_snapshot_buffer()
-{
-    return std::make_shared<mc::TemporarySnapshotBuffer>(buffer_bundle);
-}
-
-void mc::BufferStreamSurfaces::acquire_client_buffer(
-    std::function<void(graphics::Buffer* buffer)> complete)
-{
-    buffer_bundle->client_acquire(complete);
-}
-
-void mc::BufferStreamSurfaces::release_client_buffer(graphics::Buffer* buf)
-{
-    buffer_bundle->client_release(buf);
-}
-
-MirPixelFormat mc::BufferStreamSurfaces::get_stream_pixel_format()
-{
-    return buffer_bundle->properties().format;
-}
-
-geom::Size mc::BufferStreamSurfaces::stream_size()
-{
-    return buffer_bundle->properties().size;
-}
-
-void mc::BufferStreamSurfaces::resize(geom::Size const& size)
-{
-    buffer_bundle->resize(size);
-}
-
-void mc::BufferStreamSurfaces::force_requests_to_complete()
-{
-    buffer_bundle->force_requests_to_complete();
-}
-
-void mc::BufferStreamSurfaces::allow_framedropping(bool allow)
-{
-    buffer_bundle->allow_framedropping(allow);
-}
-
-int mc::BufferStreamSurfaces::buffers_ready_for_compositor(void const* user_id) const
-{
-    return buffer_bundle->buffers_ready_for_compositor(user_id);
-}
-
-void mc::BufferStreamSurfaces::drop_old_buffers()
-{
-    buffer_bundle->drop_old_buffers();
-}
-
-void mc::BufferStreamSurfaces::drop_client_requests()
-{
-    buffer_bundle->drop_client_requests();
-}
 
=== removed 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	1970-01-01 00:00:00 +0000
@@ -1,69 +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_BUFFER_STREAM_SCENE_H_
-#define MIR_COMPOSITOR_BUFFER_STREAM_SCENE_H_
-
-#include "mir/compositor/buffer_stream.h"
-
-#include <mutex>
-
-namespace mir
-{
-namespace compositor
-{
-
-class BufferIDUniqueGenerator;
-class BufferBundle;
-class BackBufferStrategy;
-
-class BufferStreamSurfaces : public BufferStream
-{
-public:
-    BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& swapper);
-    ~BufferStreamSurfaces();
-
-    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;
-
-    MirPixelFormat get_stream_pixel_format() override;
-    geometry::Size stream_size() override;
-    void resize(geometry::Size const& size) override;
-    void allow_framedropping(bool) override;
-    void force_requests_to_complete() override;
-    int buffers_ready_for_compositor(void const* user_id) const override;
-    void drop_old_buffers() override;
-    void drop_client_requests() override;
-
-protected:
-    BufferStreamSurfaces(const BufferStreamSurfaces&) = delete;
-    BufferStreamSurfaces& operator=(const BufferStreamSurfaces&) = delete;
-
-private:
-    std::shared_ptr<BufferBundle> const buffer_bundle;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_STREAM_SCENE_H_ */
 
=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2015-03-12 03:19:52 +0000
+++ src/server/compositor/default_configuration.cpp	2015-03-20 19:31:52 +0000
@@ -19,7 +19,7 @@
 #include "mir/default_server_configuration.h"
 
 #include "mir/shell/shell.h"
-#include "buffer_stream_factory.h"
+#include "buffer_queue_factory.h"
 #include "default_display_buffer_compositor_factory.h"
 #include "multi_threaded_compositor.h"
 #include "gl_renderer_factory.h"
@@ -36,14 +36,14 @@
 namespace ms = mir::scene;
 namespace mf = mir::frontend;
 
-std::shared_ptr<ms::BufferStreamFactory>
-mir::DefaultServerConfiguration::the_buffer_stream_factory()
+std::shared_ptr<ms::BufferQueueFactory>
+mir::DefaultServerConfiguration::the_buffer_queue_factory()
 {
-    return buffer_stream_factory(
+    return buffer_queue_factory(
         [this]()
         {
-            return std::make_shared<mc::BufferStreamFactory>(the_buffer_allocator(),
-                                                             the_frame_dropping_policy_factory());
+            return std::make_shared<mc::BufferQueueFactory>(the_buffer_allocator(),
+                                                            the_frame_dropping_policy_factory());
         });
 }
 
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2015-03-12 03:19:52 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2015-03-20 19:31:52 +0000
@@ -25,7 +25,6 @@
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/buffer.h"
-#include "mir/compositor/buffer_stream.h"
 #include "occlusion.h"
 #include <mutex>
 #include <cstdlib>
 
=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2015-03-06 03:52:41 +0000
+++ src/server/compositor/gl_renderer.cpp	2015-03-20 19:31:52 +0000
@@ -17,7 +17,6 @@
 
 #define MIR_LOG_COMPONENT "GL"
 #include "mir/compositor/gl_renderer.h"
-#include "mir/compositor/buffer_stream.h"
 #include "mir/compositor/destination_alpha.h"
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/buffer.h"
 
=== removed file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2015-03-06 03:52:41 +0000
+++ src/server/compositor/temporary_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,92 +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"));
-}
 
=== removed file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2015-03-06 03:52:41 +0000
+++ src/server/compositor/temporary_buffers.h	1970-01-01 00:00:00 +0000
@@ -1,76 +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;
-
-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/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2015-03-13 05:12:55 +0000
+++ src/server/frontend/session_mediator.cpp	2015-03-20 19:31:52 +0000
@@ -30,7 +30,6 @@
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/buffer.h"
 #include "mir/input/cursor_images.h"
-#include "mir/compositor/buffer_stream.h"
 #include "mir/geometry/dimensions.h"
 #include "mir/frontend/display_changer.h"
 #include "mir/graphics/display_configuration.h"
 
=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2015-03-18 18:48:02 +0000
+++ src/server/scene/basic_surface.cpp	2015-03-20 19:31:52 +0000
@@ -19,15 +19,14 @@
  */
 
 #include "basic_surface.h"
-#include "mir/compositor/buffer_stream.h"
 #include "mir/frontend/event_sink.h"
 #include "mir/input/input_channel.h"
 #include "mir/shell/input_targeter.h"
 #include "mir/input/input_sender.h"
 #include "mir/graphics/buffer.h"
 #include "mir/geometry/displacement.h"
-
 #include "mir/scene/scene_report.h"
+#include "mir/compositor/buffer_bundle.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -119,7 +118,7 @@
     geometry::Rectangle rect,
     std::weak_ptr<Surface> const& parent,
     bool nonrectangular,
-    std::shared_ptr<mc::BufferStream> const& buffer_stream,
+    std::shared_ptr<mc::BufferBundle> const& buffer_queue,
     std::shared_ptr<mi::InputChannel> const& input_channel,
     std::shared_ptr<input::InputSender> const& input_sender,
     std::shared_ptr<mg::CursorImage> const& cursor_image,
@@ -132,7 +131,7 @@
     input_mode(mi::InputReceptionMode::normal),
     nonrectangular(nonrectangular),
     custom_input_rectangles(),
-    surface_buffer_stream(buffer_stream),
+    buffer_queue(buffer_queue),
     server_input_channel(input_channel),
     input_sender(input_sender),
     cursor_image_(cursor_image),
@@ -146,32 +145,27 @@
     std::string const& name,
     geometry::Rectangle rect,
     bool nonrectangular,
-    std::shared_ptr<mc::BufferStream> const& buffer_stream,
+    std::shared_ptr<mc::BufferBundle> const& buffer_queue,
     std::shared_ptr<mi::InputChannel> const& input_channel,
     std::shared_ptr<input::InputSender> const& input_sender,
     std::shared_ptr<mg::CursorImage> const& cursor_image,
     std::shared_ptr<SceneReport> const& report) :
-    BasicSurface(name, rect, std::shared_ptr<Surface>{nullptr}, nonrectangular,buffer_stream,
+    BasicSurface(name, rect, std::shared_ptr<Surface>{nullptr}, nonrectangular, buffer_queue,
                  input_channel, input_sender, cursor_image, report)
 {
 }
 
 void ms::BasicSurface::force_requests_to_complete()
 {
-    surface_buffer_stream->force_requests_to_complete();
+    buffer_queue->force_requests_to_complete();
 }
 
 ms::BasicSurface::~BasicSurface() noexcept
 {
     report->surface_deleted(this, surface_name);
 
-    if (surface_buffer_stream) // some tests use null for surface_buffer_stream
-        surface_buffer_stream->drop_client_requests();
-}
-
-std::shared_ptr<mc::BufferStream> ms::BasicSurface::buffer_stream() const
-{
-    return surface_buffer_stream;
+    if (buffer_queue)
+        buffer_queue->drop_client_requests();
 }
 
 std::string ms::BasicSurface::name() const
@@ -217,14 +211,14 @@
 
 MirPixelFormat ms::BasicSurface::pixel_format() const
 {
-    return surface_buffer_stream->get_stream_pixel_format();
+    return buffer_queue->properties().format;
 }
 
 void ms::BasicSurface::swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete)
 {
     if (old_buffer)
     {
-        surface_buffer_stream->release_client_buffer(old_buffer);
+        buffer_queue->client_release(old_buffer);
         {
             std::unique_lock<std::mutex> lk(guard);
             first_frame_posted = true;
@@ -238,17 +232,12 @@
         observers.frame_posted(1);
     }
 
-    surface_buffer_stream->acquire_client_buffer(complete);
+    buffer_queue->client_acquire(complete);
 }
 
 void ms::BasicSurface::allow_framedropping(bool allow)
 {
-    surface_buffer_stream->allow_framedropping(allow);
-}
-
-std::shared_ptr<mg::Buffer> ms::BasicSurface::snapshot_buffer() const
-{
-    return surface_buffer_stream->lock_snapshot_buffer();
+    buffer_queue->allow_framedropping(allow);
 }
 
 bool ms::BasicSurface::supports_input() const
@@ -291,7 +280,7 @@
      * not predictable here. Such critical exceptions would arise from
      * the platform buffer allocator as a runtime_error via:
      */
-    surface_buffer_stream->resize(new_size);
+    buffer_queue->resize(new_size);
 
     // Now the buffer stream has successfully resized, update the state second;
     {
@@ -393,8 +382,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 = buffer_queue->snapshot_acquire();
+    exec(*(buffer_handle.buffer()));
 }
 
 
@@ -636,7 +625,7 @@
         visibility_ = new_visibility;
         lg.unlock();
         if (new_visibility == mir_surface_visibility_exposed)
-            surface_buffer_stream->drop_old_buffers();
+            buffer_queue->drop_old_buffers();
         observers.attrib_changed(mir_surface_attrib_visibility, visibility_);
     }
 
@@ -669,15 +658,14 @@
 {
 public:
     SurfaceSnapshot(
-        std::shared_ptr<mc::BufferStream> const& stream,
+        std::shared_ptr<mc::BufferBundle> const& bq,
         void const* compositor_id,
         geom::Rectangle const& position,
         glm::mat4 const& transform,
         float alpha,
         bool shaped,
         mg::Renderable::ID id)
-    : underlying_buffer_stream{stream},
-      compositor_buffer{nullptr},
+    : underlying_buffer_queue{bq},
       compositor_id{compositor_id},
       alpha_{alpha},
       shaped_{shaped},
@@ -693,9 +681,9 @@
  
     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 (!compositor_buffer_handle)
+            compositor_buffer_handle = underlying_buffer_queue->compositor_acquire(compositor_id);
+        return compositor_buffer_handle.buffer();
     }
 
     geom::Rectangle screen_position() const override
@@ -713,8 +701,8 @@
     mg::Renderable::ID id() const override
     { return id_; }
 private:
-    std::shared_ptr<mc::BufferStream> const underlying_buffer_stream;
-    std::shared_ptr<mg::Buffer> mutable compositor_buffer;
+    std::shared_ptr<mc::BufferBundle> const underlying_buffer_queue;
+    mc::BufferHandle mutable compositor_buffer_handle;
     void const*const compositor_id;
     float const alpha_;
     bool const shaped_;
@@ -729,7 +717,7 @@
     std::unique_lock<std::mutex> lk(guard);
 
     return std::make_unique<SurfaceSnapshot>(
-        surface_buffer_stream,
+        buffer_queue,
         compositor_id,
         surface_rect,
         transformation_matrix,
@@ -741,7 +729,7 @@
 int ms::BasicSurface::buffers_ready_for_compositor(void const* id) const
 {
     std::unique_lock<std::mutex> lk(guard);
-    return surface_buffer_stream->buffers_ready_for_compositor(id);
+    return buffer_queue->buffers_ready_for_compositor(id);
 }
 
 void ms::BasicSurface::consume(MirEvent const& event)
 
=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2015-03-12 03:19:52 +0000
+++ src/server/scene/basic_surface.h	2015-03-20 19:31:52 +0000
@@ -22,6 +22,7 @@
 #include "mir/scene/surface.h"
 #include "mir/basic_observers.h"
 #include "mir/scene/surface_observer.h"
+#include "mir/compositor/buffer_handle.h"
 
 #include "mir/geometry/rectangle.h"
 
@@ -38,7 +39,7 @@
 namespace compositor
 {
 struct BufferIPCPackage;
-class BufferStream;
+class BufferBundle;
 }
 namespace frontend { class EventSink; }
 namespace graphics
@@ -82,7 +83,7 @@
         std::string const& name,
         geometry::Rectangle rect,
         bool nonrectangular,
-        std::shared_ptr<compositor::BufferStream> const& buffer_stream,
+        std::shared_ptr<compositor::BufferBundle> const& buffer_queue,
         std::shared_ptr<input::InputChannel> const& input_channel,
         std::shared_ptr<input::InputSender> const& sender,
         std::shared_ptr<graphics::CursorImage> const& cursor_image,
@@ -93,7 +94,7 @@
         geometry::Rectangle rect,
         std::weak_ptr<Surface> const& parent,
         bool nonrectangular,
-        std::shared_ptr<compositor::BufferStream> const& buffer_stream,
+        std::shared_ptr<compositor::BufferBundle> const& buffer_queue,
         std::shared_ptr<input::InputChannel> const& input_channel,
         std::shared_ptr<input::InputSender> const& sender,
         std::shared_ptr<graphics::CursorImage> const& cursor_image,
@@ -111,7 +112,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;
 
@@ -124,8 +124,6 @@
 
     void set_input_region(std::vector<geometry::Rectangle> const& input_rectangles) override;
 
-    std::shared_ptr<compositor::BufferStream> buffer_stream() const;
-
     void resize(geometry::Size const& size) override;
     geometry::Point top_left() const override;
     geometry::Rectangle input_bounds() const override;
@@ -186,7 +184,7 @@
     input::InputReceptionMode input_mode;
     const bool nonrectangular;
     std::vector<geometry::Rectangle> custom_input_rectangles;
-    std::shared_ptr<compositor::BufferStream> const surface_buffer_stream;
+    std::shared_ptr<compositor::BufferBundle> const buffer_queue;
     std::shared_ptr<input::InputChannel> const server_input_channel;
     std::shared_ptr<input::InputSender> const input_sender;
     std::shared_ptr<graphics::CursorImage> cursor_image_;
 
=== modified file 'src/server/scene/default_configuration.cpp'
--- src/server/scene/default_configuration.cpp	2015-03-16 03:39:55 +0000
+++ src/server/scene/default_configuration.cpp	2015-03-20 19:31:52 +0000
@@ -73,7 +73,7 @@
         [this]()
         {
             return std::make_shared<ms::SurfaceAllocator>(
-                the_buffer_stream_factory(),
+                the_buffer_queue_factory(),
                 the_options()->get<int>(options::nbuffers_opt),
                 the_input_channel_factory(),
                 the_input_sender(),
 
=== modified file 'src/server/scene/surface_allocator.cpp'
--- src/server/scene/surface_allocator.cpp	2015-03-16 03:39:55 +0000
+++ src/server/scene/surface_allocator.cpp	2015-03-20 19:31:52 +0000
@@ -17,9 +17,9 @@
  */
 
 #include "surface_allocator.h"
-#include "mir/scene/buffer_stream_factory.h"
-#include "mir/compositor/buffer_stream.h"
+#include "mir/scene/buffer_queue_factory.h"
 #include "mir/input/input_channel_factory.h"
+#include "mir/compositor/buffer_bundle.h"
 #include "basic_surface.h"
 
 namespace geom=mir::geometry;
@@ -36,13 +36,13 @@
 }
 
 ms::SurfaceAllocator::SurfaceAllocator(
-    std::shared_ptr<BufferStreamFactory> const& stream_factory,
+    std::shared_ptr<BufferQueueFactory> const& buffer_queue_factory,
     int nbuffers,
     std::shared_ptr<input::InputChannelFactory> const& input_factory,
     std::shared_ptr<input::InputSender> const& input_sender,
     std::shared_ptr<mg::CursorImage> const& default_cursor_image,
     std::shared_ptr<SceneReport> const& report) :
-    buffer_stream_factory(stream_factory),
+    buffer_queue_factory(buffer_queue_factory),
     nbuffers(nbuffers),
     input_factory(input_factory),
     input_sender(input_sender),
@@ -58,10 +58,8 @@
     mg::BufferProperties buffer_properties{params.size,
                                            params.pixel_format,
                                            params.buffer_usage};
-    auto buffer_stream = buffer_stream_factory->create_buffer_stream(
-        nbuffers,
-        buffer_properties);
-    auto actual_size = geom::Rectangle{params.top_left, buffer_stream->stream_size()};
+    auto buffer_queue = buffer_queue_factory->create_buffer_queue(nbuffers, buffer_properties);
+    auto actual_size = geom::Rectangle{params.top_left, buffer_queue->size()};
 
     bool nonrectangular = has_alpha(params.pixel_format);
     auto input_channel = input_factory->make_input_channel();
@@ -70,7 +68,7 @@
         actual_size,
         params.parent,
         nonrectangular,
-        buffer_stream,
+        buffer_queue,
         input_channel,
         input_sender,
         default_cursor_image,
 
=== modified file 'src/server/scene/surface_allocator.h'
--- src/server/scene/surface_allocator.h	2015-03-16 03:39:55 +0000
+++ src/server/scene/surface_allocator.h	2015-03-20 19:31:52 +0000
@@ -34,14 +34,14 @@
 }
 namespace scene
 {
-class BufferStreamFactory;
+class BufferQueueFactory;
 class SceneReport;
 class SurfaceConfigurator;
 
 class SurfaceAllocator : public SurfaceFactory
 {
 public:
-    SurfaceAllocator(std::shared_ptr<BufferStreamFactory> const& bb_factory,
+    SurfaceAllocator(std::shared_ptr<BufferQueueFactory> const& buffer_queue_factory,
                      int buffers,
                      std::shared_ptr<input::InputChannelFactory> const& input_factory,
                      std::shared_ptr<input::InputSender> const& input_sender,
@@ -51,7 +51,7 @@
     std::shared_ptr<Surface> create_surface(SurfaceCreationParameters const& params) override;
 
 private:
-    std::shared_ptr<BufferStreamFactory> const buffer_stream_factory;
+    std::shared_ptr<BufferQueueFactory> const buffer_queue_factory;
     int const nbuffers;
     std::shared_ptr<input::InputChannelFactory> const input_factory;
     std::shared_ptr<input::InputSender> const input_sender;
 
=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2015-03-16 03:39:55 +0000
+++ src/server/symbols.map	2015-03-20 19:31:52 +0000
@@ -515,7 +515,7 @@
     mir::DefaultServerConfiguration::new_ipc_factory*;
     mir::DefaultServerConfiguration::the_android_input_dispatcher*;
     mir::DefaultServerConfiguration::the_buffer_allocator*;
-    mir::DefaultServerConfiguration::the_buffer_stream_factory*;
+    mir::DefaultServerConfiguration::the_buffer_queue_factory*;
     mir::DefaultServerConfiguration::the_clock*;
     mir::DefaultServerConfiguration::the_composite_event_filter*;
     mir::DefaultServerConfiguration::the_compositor*;
 
=== modified file 'tests/include/mir_test_doubles/mock_buffer_bundle.h'
--- tests/include/mir_test_doubles/mock_buffer_bundle.h	2015-01-21 08:53:28 +0000
+++ tests/include/mir_test_doubles/mock_buffer_bundle.h	2015-03-20 19:31:52 +0000
@@ -18,7 +18,8 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_BUFFER_BUNDLE_H_
 #define MIR_TEST_DOUBLES_MOCK_BUFFER_BUNDLE_H_
 
-#include "src/server/compositor/buffer_bundle.h"
+#include "mir/compositor/buffer_handle.h"
+#include "mir/compositor/buffer_bundle.h"
 
 #include <gmock/gmock.h>
 
@@ -37,19 +38,22 @@
     ~MockBufferBundle() noexcept
     {}
 
-    MOCK_METHOD1(client_acquire,     void(std::function<void(graphics::Buffer*)>));
-    MOCK_METHOD1(client_release,     void(graphics::Buffer*));
-    MOCK_METHOD1(compositor_acquire, std::shared_ptr<graphics::Buffer>(void const*));
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
-    MOCK_METHOD0(snapshot_acquire, std::shared_ptr<graphics::Buffer>());
-    MOCK_METHOD1(snapshot_release, void(std::shared_ptr<graphics::Buffer> const&));
+    MOCK_METHOD1(client_acquire, void(std::function<void(graphics::Buffer*)>));
+    MOCK_METHOD1(client_release, void(graphics::Buffer*));
+    MOCK_CONST_METHOD0(properties, graphics::BufferProperties());
     MOCK_METHOD1(allow_framedropping, void(bool));
-    MOCK_CONST_METHOD0(properties, graphics::BufferProperties());
-    MOCK_METHOD0(force_client_abort, void());
     MOCK_METHOD0(force_requests_to_complete, void());
     MOCK_METHOD1(resize, void(const geometry::Size &));
+    MOCK_CONST_METHOD0(size, geometry::Size());
     MOCK_METHOD0(drop_old_buffers, void());
-    int buffers_ready_for_compositor(void const*) const override { return 1; }
+    MOCK_CONST_METHOD1(buffers_ready_for_compositor, int(void const*));
+
+    // TODO: Latest gmock (1.7.0) can't handle moveable only classes.
+    // The trunk can. We should be able to mock this once released.
+    compositor::BufferHandle compositor_acquire(void const*) override
+        { return std::move(compositor::BufferHandle(nullptr, nullptr)); }
+    compositor::BufferHandle snapshot_acquire() override
+        { return std::move(compositor::BufferHandle(nullptr, nullptr)); }
     int buffers_free_for_client() const override { return 1; }
     void drop_client_requests() override {}
 };
 
=== removed file 'tests/include/mir_test_doubles/mock_buffer_stream.h'
--- tests/include/mir_test_doubles/mock_buffer_stream.h	2015-01-21 08:53:28 +0000
+++ tests/include/mir_test_doubles/mock_buffer_stream.h	1970-01-01 00:00:00 +0000
@@ -1,67 +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_TEST_DOUBLES_MOCK_BUFFER_STREAM_H_
-#define MIR_TEST_DOUBLES_MOCK_BUFFER_STREAM_H_
-
-#include "mir/compositor/buffer_stream.h"
-
-#include <gmock/gmock.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-struct MockBufferStream : public compositor::BufferStream
-{
-    int buffers_ready_{0};
-    int buffers_ready(void const*)
-    {
-        if (buffers_ready_)
-            return buffers_ready_--;
-        return 0;
-    }
-
-    MockBufferStream()
-    {
-        ON_CALL(*this, buffers_ready_for_compositor(::testing::_))
-            .WillByDefault(testing::Invoke(this, &MockBufferStream::buffers_ready));
-    }
-    MOCK_METHOD1(acquire_client_buffer, void(std::function<void(graphics::Buffer* buffer)>));
-    MOCK_METHOD1(release_client_buffer, void(graphics::Buffer*));
-    MOCK_METHOD1(lock_compositor_buffer,
-                 std::shared_ptr<graphics::Buffer>(void const*));
-    MOCK_METHOD0(lock_snapshot_buffer, std::shared_ptr<graphics::Buffer>());
-
-    MOCK_METHOD0(get_stream_pixel_format, MirPixelFormat());
-    MOCK_METHOD0(stream_size, geometry::Size());
-    MOCK_METHOD1(resize, void(geometry::Size const&));
-    MOCK_METHOD0(force_client_completion, void());
-    MOCK_METHOD1(allow_framedropping, void(bool));
-    MOCK_METHOD0(force_requests_to_complete, void());
-    MOCK_CONST_METHOD1(buffers_ready_for_compositor, int(void const*));
-    MOCK_METHOD0(drop_old_buffers, void());
-    MOCK_METHOD0(drop_client_requests, void());
-};
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_BUFFER_STREAM_H_ */
 
=== modified file 'tests/include/mir_test_doubles/mock_surface.h'
--- tests/include/mir_test_doubles/mock_surface.h	2015-02-03 15:07:44 +0000
+++ tests/include/mir_test_doubles/mock_surface.h	2015-03-20 19:31:52 +0000
@@ -21,7 +21,7 @@
 
 #include "src/server/scene/basic_surface.h"
 #include "src/server/report/null_report_factory.h"
-#include "mock_buffer_stream.h"
+#include "mock_buffer_bundle.h"
 
 #include <gmock/gmock.h>
 
@@ -39,7 +39,7 @@
             {},
             {{},{}},
             true,
-            std::make_shared<testing::NiceMock<MockBufferStream>>(),
+            std::make_shared<testing::NiceMock<MockBufferBundle>>(),
             {},
             {},
             {},
 
=== renamed file 'tests/include/mir_test_doubles/stub_buffer_stream.h' => 'tests/include/mir_test_doubles/stub_buffer_bundle.h'
--- tests/include/mir_test_doubles/stub_buffer_stream.h	2015-01-22 10:20:30 +0000
+++ tests/include/mir_test_doubles/stub_buffer_bundle.h	2015-03-20 19:31:52 +0000
@@ -16,10 +16,11 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_NULL_BUFFER_STREAM_H_
-#define MIR_TEST_DOUBLES_NULL_BUFFER_STREAM_H_
+#ifndef MIR_TEST_DOUBLES_NULL_BUFFER_BUNDLE_H_
+#define MIR_TEST_DOUBLES_NULL_BUFFER_BUNDLE_H_
 
-#include <mir/compositor/buffer_stream.h>
+#include "mir/compositor/buffer_handle.h"
+#include <mir/compositor/buffer_bundle.h>
 #include <mir_test_doubles/stub_buffer.h>
 
 namespace mir
@@ -29,42 +30,37 @@
 namespace doubles
 {
 
-class StubBufferStream : public compositor::BufferStream
+class StubBufferBundle : public compositor::BufferBundle
 {
 public:
-    StubBufferStream()
+    StubBufferBundle()
     {
         stub_compositor_buffer = std::make_shared<StubBuffer>();
     }
 
-    void acquire_client_buffer(
+    void client_acquire(
         std::function<void(graphics::Buffer* buffer)> complete) override
     {
         complete(&stub_client_buffer);
     }
 
-    void release_client_buffer(graphics::Buffer*) override
+    void client_release(graphics::Buffer*) override
     {
         ++nready;
     }
 
-    std::shared_ptr<graphics::Buffer> lock_compositor_buffer(void const*) override
+    compositor::BufferHandle compositor_acquire(void const*) override
     {
         --nready;
-        return stub_compositor_buffer;
-    }
-
-    std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() override
-    {
-        return stub_compositor_buffer;
-    }
-
-    MirPixelFormat get_stream_pixel_format() override
-    {
-        return MirPixelFormat();
-    }
-
-    geometry::Size stream_size() override
+        return compositor::BufferHandle(stub_compositor_buffer, nullptr);
+    }
+
+    compositor::BufferHandle snapshot_acquire() override
+    {
+        return compositor::BufferHandle(stub_compositor_buffer, nullptr);
+    }
+
+    geometry::Size size() const override
     {
         return geometry::Size();
     }
@@ -81,11 +77,18 @@
     {
     }
 
+    int buffers_free_for_client() const override { return 0; }
+
     int buffers_ready_for_compositor(void const*) const override { return nready; }
 
     void drop_old_buffers() override {}
     void drop_client_requests() override {}
 
+    graphics::BufferProperties properties() const override
+    { return graphics::BufferProperties(geometry::Size{0, 0},
+                                        mir_pixel_format_invalid,
+                                        graphics::BufferUsage::undefined); }
+
     StubBuffer stub_client_buffer;
     std::shared_ptr<graphics::Buffer> stub_compositor_buffer;
     int nready = 0;
@@ -95,4 +98,4 @@
 }
 } // namespace mir
 
-#endif /* MIR_TEST_DOUBLES_NULL_BUFFER_STREAM_H_ */
+#endif /* MIR_TEST_DOUBLES_NULL_BUFFER_BUNDLE_H_ */
 
=== modified file 'tests/integration-tests/compositor/CMakeLists.txt'
--- tests/integration-tests/compositor/CMakeLists.txt	2013-07-24 05:13:16 +0000
+++ tests/integration-tests/compositor/CMakeLists.txt	2015-03-20 19:31:52 +0000
@@ -2,7 +2,6 @@
   APPEND INTEGRATION_TESTS_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/test_swapping_swappers.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_synchronizer.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_stream.cpp
 )
 
 set(
 
=== removed file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2015-03-06 03:52:41 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	1970-01-01 00:00:00 +0000
@@ -1,405 +0,0 @@
-/*
- * Copyright © 2013-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: Alexandros Frantzis <[e-mail]>
- */
-
-#include "src/server/compositor/buffer_stream_surfaces.h"
-#include "mir/graphics/graphic_buffer_allocator.h"
-
-#include "src/server/compositor/buffer_queue.h"
-#include "src/server/compositor/timeout_frame_dropping_policy_factory.h"
-
-#include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/stub_buffer_allocator.h"
-#include "mir_test_doubles/mock_timer.h"
-#include "mir_test/signal.h"
-
-#include <gmock/gmock.h>
-
-#include <condition_variable>
-#include <thread>
-#include <chrono>
-#include <atomic>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace mtd = mir::test::doubles;
-namespace mt =mir::test;
-namespace geom = mir::geometry;
-
-using namespace ::testing;
-
-namespace
-{
-
-struct BufferStreamSurfaces : mc::BufferStreamSurfaces
-{
-    using mc::BufferStreamSurfaces::BufferStreamSurfaces;
-
-    void acquire_client_buffer_async(mg::Buffer*& buffer,
-        std::shared_ptr<mt::Signal> const& signal)
-    {
-        acquire_client_buffer(
-            [signal, &buffer](mg::Buffer* new_buffer)
-            {
-               buffer = new_buffer;
-               signal->raise();
-            });
-    }
-
-    // Convenient functions to allow tests to be written in linear style
-    mg::Buffer* acquire_client_buffer_blocking()
-    {
-        mg::Buffer* buffer = nullptr;
-        auto signal = std::make_shared<mt::Signal>();
-        acquire_client_buffer_async(buffer, signal);
-        signal->wait();
-        return buffer;
-    }
-
-    void swap_client_buffers_blocking(mg::Buffer*& buffer)
-    {
-        if (buffer)
-            release_client_buffer(buffer);
-
-        buffer = acquire_client_buffer_blocking();
-    }
-};
-
-struct BufferStreamTest : public ::testing::Test
-{
-    BufferStreamTest()
-        : clock{std::make_shared<mt::FakeClock>()},
-          timer{std::make_shared<mtd::FakeTimer>(clock)},
-          frame_drop_timeout{1000},
-          nbuffers{3},
-          buffer_stream{create_bundle()}
-    {
-    }
-
-    int buffers_free_for_client() const
-    {
-        return buffer_queue->buffers_free_for_client();
-    }
-
-    std::shared_ptr<mc::BufferBundle> create_bundle()
-    {
-        auto allocator = std::make_shared<mtd::StubBufferAllocator>();
-        mg::BufferProperties properties{geom::Size{380, 210},
-                                        mir_pixel_format_abgr_8888,
-                                        mg::BufferUsage::hardware};
-        mc::TimeoutFrameDroppingPolicyFactory policy_factory{timer,
-                                                             frame_drop_timeout};
-
-        buffer_queue = std::make_shared<mc::BufferQueue>(nbuffers,
-                                                         allocator,
-                                                         properties,
-                                                         policy_factory);
-
-        return buffer_queue;
-    }
-
-    std::shared_ptr<mt::FakeClock> clock;
-    std::shared_ptr<mtd::FakeTimer> timer;
-    std::chrono::milliseconds const frame_drop_timeout;
-    const int nbuffers;
-    std::shared_ptr<mc::BufferQueue> buffer_queue;
-    BufferStreamSurfaces buffer_stream;
-};
-
-}
-
-TEST_F(BufferStreamTest, gives_same_back_buffer_until_more_available)
-{
-    mg::Buffer* client1 = buffer_stream.acquire_client_buffer_blocking();
-    auto client1_id = client1->id();
-    buffer_stream.release_client_buffer(client1);
-
-    auto comp1 = buffer_stream.lock_compositor_buffer(nullptr);
-    auto comp2 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    EXPECT_EQ(comp1->id(), comp2->id());
-    EXPECT_EQ(comp1->id(), client1_id);
-
-    comp1.reset();
-
-    mg::Buffer* client2 = buffer_stream.acquire_client_buffer_blocking();
-    auto client2_id = client2->id();
-    buffer_stream.release_client_buffer(client2);
-
-    auto comp3 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    EXPECT_NE(client1_id, comp3->id());
-    EXPECT_EQ(client2_id, comp3->id());
-
-    comp2.reset();
-    auto comp3_id = comp3->id();
-    comp3.reset();
-
-    auto comp4 = buffer_stream.lock_compositor_buffer(nullptr);
-    EXPECT_EQ(comp3_id, comp4->id());
-}
-
-TEST_F(BufferStreamTest, gives_all_monitors_the_same_buffer)
-{
-    mg::Buffer* client_buffer{nullptr};
-    int const prefill = buffers_free_for_client();
-    for (int i = 0; i < prefill; ++i)
-        buffer_stream.swap_client_buffers_blocking(client_buffer);
-
-    auto first_monitor = buffer_stream.lock_compositor_buffer(0);
-    auto first_compositor_id = first_monitor->id();
-    first_monitor.reset();
-
-    for (int m = 1; m <= 10; m++)
-    {
-        const void *th = reinterpret_cast<const void*>(m);
-        auto monitor = buffer_stream.lock_compositor_buffer(th);
-        ASSERT_EQ(first_compositor_id, monitor->id());
-    }
-}
-
-TEST_F(BufferStreamTest, gives_different_back_buffer_asap)
-{
-    buffer_stream.release_client_buffer(buffer_stream.acquire_client_buffer_blocking());
-    auto comp1 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    buffer_stream.release_client_buffer(buffer_stream.acquire_client_buffer_blocking());
-    auto comp2 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    EXPECT_NE(comp1->id(), comp2->id());
-
-    comp1.reset();
-    comp2.reset();
-}
-
-TEST_F(BufferStreamTest, resize_affects_client_buffers_immediately)
-{
-    auto old_size = buffer_stream.stream_size();
-
-    mg::Buffer* client = buffer_stream.acquire_client_buffer_blocking();
-    EXPECT_EQ(old_size, client->size());
-    buffer_stream.release_client_buffer(client);
-
-    buffer_stream.lock_compositor_buffer(this);
-
-    geom::Size const new_size
-    {
-        old_size.width.as_int() * 2,
-        old_size.height.as_int() * 3
-    };
-    buffer_stream.resize(new_size);
-    EXPECT_EQ(new_size, buffer_stream.stream_size());
-
-    client = buffer_stream.acquire_client_buffer_blocking();
-    EXPECT_EQ(new_size, client->size());
-    buffer_stream.release_client_buffer(client);
-
-    buffer_stream.lock_compositor_buffer(this);
-
-    buffer_stream.resize(old_size);
-    EXPECT_EQ(old_size, buffer_stream.stream_size());
-
-    buffer_stream.lock_compositor_buffer(this);
-
-    client = buffer_stream.acquire_client_buffer_blocking();
-    EXPECT_EQ(old_size, client->size());
-    buffer_stream.release_client_buffer(client);
-}
-
-TEST_F(BufferStreamTest, compositor_gets_resized_buffers)
-{
-    auto old_size = buffer_stream.stream_size();
-
-    mg::Buffer* client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-
-    geom::Size const new_size
-    {
-        old_size.width.as_int() * 2,
-        old_size.height.as_int() * 3
-    };
-    buffer_stream.resize(new_size);
-    EXPECT_EQ(new_size, buffer_stream.stream_size());
-
-    auto comp1 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-
-    EXPECT_EQ(old_size, comp1->size());
-    comp1.reset();
-
-    auto comp2 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-
-    EXPECT_EQ(new_size, comp2->size());
-    comp2.reset();
-
-    auto comp3 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-
-    EXPECT_EQ(new_size, comp3->size());
-    comp3.reset();
-
-    buffer_stream.resize(old_size);
-    EXPECT_EQ(old_size, buffer_stream.stream_size());
-
-    auto comp4 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    // No client frames "drawn" since resize(old_size), so compositor gets new_size
-    client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-    EXPECT_EQ(new_size, comp4->size());
-    comp4.reset();
-
-    auto comp5 = buffer_stream.lock_compositor_buffer(nullptr);
-
-    // Generate a new frame, which should be back to old_size now
-    client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-    EXPECT_EQ(old_size, comp5->size());
-    comp5.reset();
-}
-
-TEST_F(BufferStreamTest, can_get_partly_released_back_buffer)
-{
-    mg::Buffer* client = buffer_stream.acquire_client_buffer_blocking();
-    buffer_stream.release_client_buffer(client);
-
-    int a, b, c;
-    auto comp1 = buffer_stream.lock_compositor_buffer(&a);
-    auto comp2 = buffer_stream.lock_compositor_buffer(&b);
-
-    EXPECT_EQ(comp1->id(), comp2->id());
-
-    comp1.reset();
-
-    auto comp3 = buffer_stream.lock_compositor_buffer(&c);
-
-    EXPECT_EQ(comp2->id(), comp3->id());
-}
-
-namespace
-{
-
-void client_loop(int nframes, BufferStreamSurfaces& stream)
-{
-    mg::Buffer* out_buffer{nullptr};
-    for (int f = 0; f < nframes; f++)
-    {
-        stream.swap_client_buffers_blocking(out_buffer);
-        ASSERT_NE(nullptr, out_buffer);
-        std::this_thread::yield();
-    }
-}
-
-void compositor_loop(mc::BufferStream &stream,
-                     std::atomic<bool> &done)
-{
-    while (!done.load())
-    {
-        auto comp1 = stream.lock_compositor_buffer(nullptr);
-        ASSERT_NE(nullptr, comp1);
-
-        // Also stress test getting a second compositor buffer before yielding
-        auto comp2 = stream.lock_compositor_buffer(nullptr);
-        ASSERT_NE(nullptr, comp2);
-
-        std::this_thread::yield();
-
-        comp1.reset();
-        comp2.reset();
-    }
-}
-
-void snapshot_loop(mc::BufferStream &stream,
-                   std::atomic<bool> &done)
-{
-    while (!done.load())
-    {
-        auto out_region = stream.lock_snapshot_buffer();
-        ASSERT_NE(nullptr, out_region);
-        std::this_thread::yield();
-    }
-}
-
-}
-
-TEST_F(BufferStreamTest, stress_test_distinct_buffers)
-{
-    // More would be good, but armhf takes too long
-    const int num_snapshotters{2};
-    const int num_frames{200};
-
-    std::atomic<bool> done;
-    done = false;
-
-    std::thread client(client_loop,
-                       num_frames,
-                       std::ref(buffer_stream));
-
-    std::thread compositor(compositor_loop,
-                           std::ref(buffer_stream),
-                           std::ref(done));
-
-    std::vector<std::shared_ptr<std::thread>> snapshotters;
-    for (unsigned int i = 0; i < num_snapshotters; i++)
-    {
-        snapshotters.push_back(
-            std::make_shared<std::thread>(snapshot_loop,
-                                          std::ref(buffer_stream),
-                                          std::ref(done)));
-    }
-
-    client.join();
-
-    done = true;
-
-    buffer_stream.force_requests_to_complete();
-
-    compositor.join();
-
-    for (auto &s : snapshotters)
-        s->join();
-}
-
-TEST_F(BufferStreamTest, blocked_client_is_released_on_timeout)
-{
-    using namespace testing;
-
-    mg::Buffer* placeholder{nullptr};
-
-    // Grab all the buffers...
-    int max = buffers_free_for_client();
-    for (int i = 0; i < max; ++i)
-    {
-        placeholder = buffer_stream.acquire_client_buffer_blocking();
-        buffer_stream.release_client_buffer(placeholder);
-    }
-
-    auto swap_completed = std::make_shared<mt::Signal>();
-    buffer_stream.acquire_client_buffer([swap_completed](mg::Buffer*) {swap_completed->raise();});
-
-    EXPECT_FALSE(swap_completed->raised());
-    clock->advance_time(frame_drop_timeout + std::chrono::milliseconds{1});
-
-    EXPECT_TRUE(swap_completed->wait_for(std::chrono::milliseconds{100}));
-}
 
=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2015-01-21 07:34:50 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2015-03-20 19:31:52 +0000
@@ -20,8 +20,8 @@
 #include "mir_test_doubles/stub_frame_dropping_policy_factory.h"
 #include "multithread_harness.h"
 
-#include "src/server/compositor/buffer_queue.h"
-#include "src/server/compositor/buffer_stream_surfaces.h"
+#include "mir/compositor/buffer_handle.h"
+#include "mir/compositor/buffer_queue.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 
 #include <gmock/gmock.h>
@@ -105,7 +105,6 @@
                     {
                         auto b = switching_bundle->compositor_acquire(0);
                         std::this_thread::yield();
-                        switching_bundle->compositor_release(b);
                     }
                 });
 
@@ -149,7 +148,6 @@
                     {
                         auto b = switching_bundle->compositor_acquire(0);
                         std::this_thread::yield();
-                        switching_bundle->compositor_release(b);
                     }
                 });
 
 
=== modified file 'tests/integration-tests/graphics/android/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/android/test_buffer_integration.cpp	2015-01-22 09:00:14 +0000
+++ tests/integration-tests/graphics/android/test_buffer_integration.cpp	2015-03-20 19:31:52 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "src/platforms/android/server/android_graphic_buffer_allocator.h"
-#include "src/server/compositor/buffer_queue.h"
+#include "mir/compositor/buffer_queue.h"
 #include "src/server/report/null_report_factory.h"
 #include "mir/graphics/android/native_buffer.h"
 #include "mir/graphics/buffer_properties.h"
 
=== modified file 'tests/integration-tests/surface_composition.cpp'
--- tests/integration-tests/surface_composition.cpp	2015-02-03 15:07:44 +0000
+++ tests/integration-tests/surface_composition.cpp	2015-03-20 19:31:52 +0000
@@ -18,8 +18,7 @@
 
 #include "src/server/scene/basic_surface.h"
 #include "src/server/report/null_report_factory.h"
-#include "src/server/compositor/buffer_stream_surfaces.h"
-#include "src/server/compositor/buffer_queue.h"
+#include "mir/compositor/buffer_queue.h"
 
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_frame_dropping_policy_factory.h"
@@ -49,7 +48,7 @@
             std::string("SurfaceComposition"),
             geom::Rectangle{{},{}},
             false,
-            create_buffer_stream(),
+            create_buffer_bundle(),
             create_input_channel(),
             create_input_sender(),
             create_cursor_image(),
@@ -59,12 +58,6 @@
 
     int const number_of_buffers = 3;
 
-    auto create_buffer_stream() const
-    ->std::shared_ptr<mc::BufferStream>
-    {
-        return std::make_shared<mc::BufferStreamSurfaces>(create_buffer_bundle());
-    }
-
     auto create_buffer_bundle() const
     -> std::shared_ptr<mc::BufferBundle>
     {
 
=== modified file 'tests/integration-tests/test_exchange_buffer.cpp'
--- tests/integration-tests/test_exchange_buffer.cpp	2015-03-16 03:39:55 +0000
+++ tests/integration-tests/test_exchange_buffer.cpp	2015-03-20 19:31:52 +0000
@@ -26,8 +26,9 @@
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/buffer_ipc_message.h"
 #include "mir/graphics/platform_operation_message.h"
-#include "mir/scene/buffer_stream_factory.h"
-#include "mir/compositor/buffer_stream.h"
+#include "mir/scene/buffer_queue_factory.h"
+#include "mir/compositor/buffer_handle.h"
+#include "mir/compositor/buffer_bundle.h"
 #include "mir_toolkit/mir_client_library.h"
 #include "src/client/mir_connection.h"
 #include <chrono>
@@ -54,14 +55,14 @@
     return arg;
 }
 
-struct StubStream : public mc::BufferStream
+struct StubQueue : public mc::BufferBundle
 {
-    StubStream(std::vector<mg::BufferID> const& ids) :
+    StubQueue(std::vector<mg::BufferID> const& ids) :
         buffer_id_seq(ids)
     {
     }
 
-    void acquire_client_buffer(std::function<void(mg::Buffer* buffer)> complete)
+    void client_acquire(std::function<void(mg::Buffer* buffer)> complete)
     {
         std::shared_ptr<mg::Buffer> stub_buffer;
         if (buffers_acquired < buffer_id_seq.size())
@@ -73,13 +74,11 @@
         complete(stub_buffer.get());
     }
 
-    void release_client_buffer(mg::Buffer*) {}
-    std::shared_ptr<mg::Buffer> lock_compositor_buffer(void const*)
-    { return std::make_shared<mtd::StubBuffer>(); }
-    std::shared_ptr<mg::Buffer> lock_snapshot_buffer()
-    { return std::make_shared<mtd::StubBuffer>(); }
-    MirPixelFormat get_stream_pixel_format() { return mir_pixel_format_abgr_8888; }
-    geom::Size stream_size() { return geom::Size{1,212121}; }
+    void client_release(mg::Buffer*) {}
+    mc::BufferHandle compositor_acquire(void const*)
+        { return std::move(mc::BufferHandle(std::make_shared<mtd::StubBuffer>(), nullptr)); }
+    mc::BufferHandle snapshot_acquire()
+        { return std::move(mc::BufferHandle(std::make_shared<mtd::StubBuffer>(), nullptr)); }
     void resize(geom::Size const&) {};
     void allow_framedropping(bool) {};
     void force_requests_to_complete() {};
@@ -87,20 +86,26 @@
     void drop_old_buffers() {}
     void drop_client_requests() override {}
 
+    mg::BufferProperties properties() const override
+        { return mg::BufferProperties(geom::Size{0, 0},
+                     mir_pixel_format_invalid,
+                     mg::BufferUsage::undefined); }
+    geom::Size size() const override { return geom::Size{1,212121}; }
+    int buffers_free_for_client() const override { return 0; }
+
     std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
     std::vector<mg::BufferID> const buffer_id_seq;
     unsigned int buffers_acquired{0};
 };
 
-struct StubStreamFactory : public msc::BufferStreamFactory
+struct StubQueueFactory : public msc::BufferQueueFactory
 {
-    StubStreamFactory(std::vector<mg::BufferID> const& ids) :
+    StubQueueFactory(std::vector<mg::BufferID> const& ids) :
         buffer_id_seq(ids)
     {}
 
-    std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        int, mg::BufferProperties const&) override
-    { return std::make_shared<StubStream>(buffer_id_seq); }
+    std::shared_ptr<mc::BufferBundle> create_buffer_queue(int, mg::BufferProperties const&) override
+    { return std::make_shared<StubQueue>(buffer_id_seq); }
     std::vector<mg::BufferID> const buffer_id_seq;
 };
 
@@ -176,7 +181,7 @@
     ExchangeServerConfiguration(
         std::vector<mg::BufferID> const& id_seq,
         std::shared_ptr<mg::PlatformIpcOperations> const& ipc_ops) :
-        stream_factory{std::make_shared<StubStreamFactory>(id_seq)},
+        queue_factory{std::make_shared<StubQueueFactory>(id_seq)},
         platform{std::make_shared<StubPlatform>(ipc_ops)}
     {
     }
@@ -186,12 +191,12 @@
         return platform;
     }
 
-    std::shared_ptr<msc::BufferStreamFactory> the_buffer_stream_factory() override
+    std::shared_ptr<msc::BufferQueueFactory> the_buffer_queue_factory() override
     {
-        return stream_factory;
+        return queue_factory;
     }
 
-    std::shared_ptr<msc::BufferStreamFactory> const stream_factory;
+    std::shared_ptr<msc::BufferQueueFactory> const queue_factory;
     std::shared_ptr<mg::Platform> const platform;
 };
 
 
=== modified file 'tests/integration-tests/test_session.cpp'
--- tests/integration-tests/test_session.cpp	2015-03-12 03:19:52 +0000
+++ tests/integration-tests/test_session.cpp	2015-03-20 19:31:52 +0000
@@ -25,7 +25,6 @@
 #include "mir/scene/surface.h"
 #include "mir/scene/surface_creation_parameters.h"
 #include "mir/scene/null_session_listener.h"
-#include "mir/compositor/buffer_stream.h"
 #include "mir/compositor/renderer.h"
 #include "mir/compositor/renderer_factory.h"
 #include "mir/frontend/connector.h"
 
=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-03-12 03:19:52 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-03-20 19:31:52 +0000
@@ -21,11 +21,11 @@
 #include "src/server/report/null_report_factory.h"
 #include "src/server/scene/surface_stack.h"
 #include "src/server/compositor/gl_renderer_factory.h"
+#include "mir_test_doubles/mock_buffer_bundle.h"
 #include "src/server/scene/basic_surface.h"
 #include "src/server/compositor/default_display_buffer_compositor_factory.h"
 #include "src/server/compositor/multi_threaded_compositor.h"
 #include "mir_test/fake_shared.h"
-#include "mir_test_doubles/mock_buffer_stream.h"
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/stub_renderer.h"
 #include "mir_test_doubles/stub_display_buffer.h"
@@ -120,27 +120,24 @@
 {
     SurfaceStackCompositor() :
         timeout{std::chrono::system_clock::now() + std::chrono::seconds(5)},
-        mock_buffer_stream(std::make_shared<testing::NiceMock<mtd::MockBufferStream>>()),
+        mock_buffer_bundle(std::make_shared<testing::NiceMock<mtd::MockBufferBundle>>()),
         stub_surface{std::make_shared<ms::BasicSurface>(
             std::string("stub"),
             geom::Rectangle{{0,0},{1,1}},
             false,
-            mock_buffer_stream,
+            mock_buffer_bundle,
             std::shared_ptr<mir::input::InputChannel>(),
             std::shared_ptr<mtd::StubInputSender>(),
             std::shared_ptr<mg::CursorImage>(),
             null_scene_report)}
     {
-        using namespace testing;
-        ON_CALL(*mock_buffer_stream, lock_compositor_buffer(_))
-            .WillByDefault(Return(mt::fake_shared(stubbuf)));
     }
     std::shared_ptr<ms::SceneReport> null_scene_report{mr::null_scene_report()};
     ms::SurfaceStack stack{null_scene_report};
     std::shared_ptr<mc::CompositorReport> null_comp_report{mr::null_compositor_report()};
     StubRendererFactory renderer_factory;
     std::chrono::system_clock::time_point timeout;
-    std::shared_ptr<mtd::MockBufferStream> mock_buffer_stream;
+    std::shared_ptr<mtd::MockBufferBundle> mock_buffer_bundle;
     std::shared_ptr<ms::BasicSurface> stub_surface;
     ms::SurfaceCreationParameters default_params;
     mtd::StubBuffer stubbuf;
@@ -203,7 +200,7 @@
 TEST_F(SurfaceStackCompositor, compositor_runs_until_all_surfaces_buffers_are_consumed)
 {
     using namespace testing;
-    ON_CALL(*mock_buffer_stream, buffers_ready_for_compositor(_))
+    ON_CALL(*mock_buffer_bundle, buffers_ready_for_compositor(_))
         .WillByDefault(Return(5));
 
     mc::MultiThreadedCompositor mt_compositor(
@@ -224,7 +221,7 @@
 TEST_F(SurfaceStackCompositor, bypassed_compositor_runs_until_all_surfaces_buffers_are_consumed)
 {
     using namespace testing;
-    ON_CALL(*mock_buffer_stream, buffers_ready_for_compositor(_))
+    ON_CALL(*mock_buffer_bundle, buffers_ready_for_compositor(_))
         .WillByDefault(Return(5));
 
     stub_surface->resize(geom::Size{10,10});
@@ -247,7 +244,7 @@
 TEST_F(SurfaceStackCompositor, an_empty_scene_retriggers)
 {
     using namespace testing;
-    ON_CALL(*mock_buffer_stream, buffers_ready_for_compositor(_))
+    ON_CALL(*mock_buffer_bundle, buffers_ready_for_compositor(_))
         .WillByDefault(Return(0));
 
     mc::MultiThreadedCompositor mt_compositor(
@@ -311,8 +308,8 @@
 TEST_F(SurfaceStackCompositor, buffer_updates_trigger_composition)
 {
     using namespace testing;
-    ON_CALL(*mock_buffer_stream, buffers_ready_for_compositor(_))
-        .WillByDefault(testing::Return(1));
+    ON_CALL(*mock_buffer_bundle, buffers_ready_for_compositor(_))
+        .WillByDefault(Return(1));
     stack.add_surface(stub_surface, default_params.depth, default_params.input_mode);
     stub_surface->swap_buffers(&stubbuf, [](mg::Buffer*){});
 
 
=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2015-03-16 03:39:55 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2015-03-20 19:31:52 +0000
@@ -23,12 +23,12 @@
 #include "mir/compositor/compositor.h"
 #include "mir/compositor/display_buffer_compositor.h"
 #include "mir/compositor/scene.h"
-#include "mir/compositor/buffer_stream.h"
-#include "mir/scene/buffer_stream_factory.h"
+#include "mir/compositor/buffer_bundle.h"
+#include "mir/scene/buffer_queue_factory.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_buffer_bundle.h"
 
 #include "mir_toolkit/mir_client_library.h"
 
@@ -49,22 +49,23 @@
 {
 char const* const mir_test_socket = mtf::test_socket_file().c_str();
 
-class CountingBufferStream : public mtd::StubBufferStream
+class CountingBufferBundle : public mtd::StubBufferBundle
 {
 public:
-    CountingBufferStream(int render_operations_fd)
+    CountingBufferBundle(int render_operations_fd)
      : render_operations_fd(render_operations_fd)
     {
     }
 
-    std::shared_ptr<mg::Buffer> lock_compositor_buffer(void const*) override
-        { return std::make_shared<mtd::StubBuffer>(); }
-
-    std::shared_ptr<mg::Buffer> lock_snapshot_buffer() override
-        { return std::make_shared<mtd::StubBuffer>(); }
-
-    MirPixelFormat get_stream_pixel_format() override
-        { return mir_pixel_format_abgr_8888; }
+    mc::BufferHandle compositor_acquire(void const*) override
+    {
+        return std::move(mc::BufferHandle(nullptr, nullptr));
+    }
+
+    mc::BufferHandle snapshot_acquire() override
+    {
+        return std::move(mc::BufferHandle(nullptr, nullptr));
+    }
 
     void allow_framedropping(bool) override
     {
@@ -75,18 +76,17 @@
     int render_operations_fd;
 };
 
-class StubStreamFactory : public ms::BufferStreamFactory
+class StubQueueFactory : public ms::BufferQueueFactory
 {
 public:
-    StubStreamFactory(int render_operations_fd)
+    StubQueueFactory(int render_operations_fd)
      : render_operations_fd(render_operations_fd)
     {
     }
 
-    std::shared_ptr<mc::BufferStream> create_buffer_stream(
-        int, mg::BufferProperties const&) override
+    std::shared_ptr<mc::BufferBundle> create_buffer_queue(int, mg::BufferProperties const&) override
     {
-        return std::make_shared<CountingBufferStream>(render_operations_fd);
+        return std::make_shared<CountingBufferBundle>(render_operations_fd);
     }
 private:
     int render_operations_fd;
@@ -128,11 +128,11 @@
                 close(rendering_ops_pipe[1]);
         }
 
-        std::shared_ptr<ms::BufferStreamFactory> the_buffer_stream_factory() override
+        std::shared_ptr<ms::BufferQueueFactory> the_buffer_queue_factory() override
         {
-            if (!stub_stream_factory)
-                stub_stream_factory = std::make_shared<StubStreamFactory>(rendering_ops_pipe[1]);
-            return stub_stream_factory;
+            if (!stub_queue_factory)
+            	stub_queue_factory = std::make_shared<StubQueueFactory>(rendering_ops_pipe[1]);
+            return stub_queue_factory;
         }
 
         int num_of_swapinterval_devices()
@@ -147,7 +147,7 @@
         }
 
         int rendering_ops_pipe[2];
-        std::shared_ptr<StubStreamFactory> stub_stream_factory;
+        std::shared_ptr<StubQueueFactory> stub_queue_factory;
     } server_config;
 
     launch_server_process(server_config);
 
=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2015-03-20 19:31:52 +0000
@@ -1,7 +1,6 @@
 list(APPEND UNIT_TEST_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_display_buffer_compositor.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_stream.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_temporary_buffers.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_handle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_queue.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gl_renderer.cpp
 
=== added file 'tests/unit-tests/compositor/test_buffer_handle.cpp'
--- tests/unit-tests/compositor/test_buffer_handle.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/compositor/test_buffer_handle.cpp	2015-03-20 19:31:52 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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_test_doubles/stub_buffer.h"
+#include "mir/compositor/buffer_handle.h"
+#include "mir_test/fake_shared.h"
+
+namespace mc = mir::compositor;
+namespace mg = mir::graphics;
+namespace mt = mir::test;
+namespace mtd = mir::test::doubles;
+
+TEST(BufferHandleTest, can_contain_handout_and_release_buffer)
+{
+    mtd::StubBuffer mock_buffer;
+
+    mc::BufferHandle buffer_handle(
+                         mt::fake_shared(mock_buffer),
+                         [&](mg::Buffer* b)
+                         {
+                             ASSERT_EQ(b, &mock_buffer);
+                         });
+
+    ASSERT_EQ(buffer_handle.buffer().get(), &mock_buffer);
+}
 
=== modified file 'tests/unit-tests/compositor/test_buffer_queue.cpp'
--- tests/unit-tests/compositor/test_buffer_queue.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/compositor/test_buffer_queue.cpp	2015-03-20 19:31:52 +0000
@@ -17,7 +17,8 @@
  *              Alberto Aguirre <[e-mail]>
  */
 
-#include "src/server/compositor/buffer_queue.h"
+#include "mir/compositor/buffer_queue.h"
+#include "mir/compositor/buffer_handle.h"
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/stub_frame_dropping_policy_factory.h"
@@ -155,7 +156,7 @@
 {
    while (!done)
    {
-       bundle.compositor_release(bundle.compositor_acquire(nullptr));
+       bundle.compositor_acquire(nullptr);
        std::this_thread::yield();
    }
 }
@@ -165,7 +166,7 @@
 {
    while (!done)
    {
-       bundle.snapshot_release(bundle.snapshot_acquire());
+       bundle.snapshot_acquire();
        std::this_thread::yield();
    }
 }
@@ -196,10 +197,8 @@
 
 TEST_F(BufferQueueTest, buffer_queue_of_one_is_supported)
 {
-    std::unique_ptr<mc::BufferQueue> q;
-    ASSERT_NO_THROW(q = std::move(
-        std::unique_ptr<mc::BufferQueue>(
-            new mc::BufferQueue(1, allocator, basic_properties, policy_factory))));
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(1, allocator, basic_properties, policy_factory));
     ASSERT_THAT(q, Ne(nullptr));
 
     auto handle = client_acquire_async(*q);
@@ -212,18 +211,18 @@
     auto next_request = client_acquire_async(*q);
     EXPECT_THAT(next_request->has_acquired_buffer(), Eq(false));
 
-    auto comp_buffer = q->compositor_acquire(this);
-    auto client_id = handle->id();
-
-    /* Client and compositor always share the same buffer */
-    EXPECT_THAT(client_id, Eq(comp_buffer->id()));
-
-    EXPECT_NO_THROW(handle->release_buffer());
-    EXPECT_NO_THROW(q->compositor_release(comp_buffer));
+    {
+        auto comp_buffer_handle = q->compositor_acquire(this);
+        auto client_id = handle->id();
+
+        /* Client and compositor always share the same buffer */
+        EXPECT_THAT(client_id, Eq(comp_buffer_handle.buffer()->id()));
+
+        EXPECT_NO_THROW(handle->release_buffer());
+    }
 
     /* Simulate a composite pass */
-    comp_buffer = q->compositor_acquire(this);
-    q->compositor_release(comp_buffer);
+    q->compositor_acquire(this);
 
     /* The request should now be fullfilled after compositor
      * released the buffer
@@ -234,27 +233,29 @@
 
 TEST_F(BufferQueueTest, buffer_queue_of_one_supports_resizing)
 {
-    mc::BufferQueue q(1, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(1, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
     const geom::Size expect_size{10, 20};
-    q.resize(expect_size);
+    q->resize(expect_size);
 
-    auto handle = client_acquire_async(q);
+    auto handle = client_acquire_async(*q);
     ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
     auto buffer = handle->buffer();
     ASSERT_THAT(buffer->size(), Eq(expect_size));
-
-    /* Client and compositor share the same buffer so
-     * expect the new size
-     */
-    std::shared_ptr<mg::Buffer> comp_buffer;
-    ASSERT_NO_THROW(comp_buffer = q.compositor_acquire(this));
-
-    EXPECT_THAT(buffer->size(), Eq(expect_size));
-    EXPECT_NO_THROW(q.compositor_release(comp_buffer));
+    {
+        /* Client and compositor share the same buffer so
+         * expect the new size
+         */
+    	auto comp_buffer_handle = q->compositor_acquire(this);
+        ASSERT_NO_THROW(comp_buffer_handle.buffer());
+
+        EXPECT_THAT(buffer->size(), Eq(expect_size));
+    }
 
     EXPECT_NO_THROW(handle->release_buffer());
-    EXPECT_NO_THROW(q.compositor_release(q.compositor_acquire(this)));
+    EXPECT_NO_THROW(q->compositor_acquire(this));
 }
 
 TEST_F(BufferQueueTest, framedropping_is_disabled_by_default)
@@ -302,25 +303,27 @@
 TEST_F(BufferQueueTest, clients_can_have_multiple_pending_completions)
 {
     int const nbuffers = 3;
-    mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
-    int const prefill = q.buffers_free_for_client();
+    int const prefill = q->buffers_free_for_client();
     ASSERT_THAT(prefill, Gt(0));
     for (int i = 0; i < prefill; ++i)
     {
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
         handle->release_buffer();
     }
 
-    auto handle1 = client_acquire_async(q);
+    auto handle1 = client_acquire_async(*q);
     ASSERT_THAT(handle1->has_acquired_buffer(), Eq(false));
 
-    auto handle2 = client_acquire_async(q);
+    auto handle2 = client_acquire_async(*q);
     ASSERT_THAT(handle1->has_acquired_buffer(), Eq(false));
 
     for (int i = 0; i < nbuffers + 1; ++i)
-        q.compositor_release(q.compositor_acquire(this));
+        q->compositor_acquire(this);
 
     EXPECT_THAT(handle1->has_acquired_buffer(), Eq(true));
     EXPECT_THAT(handle2->has_acquired_buffer(), Eq(true));
@@ -334,27 +337,32 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-        ASSERT_THAT(q.framedropping_allowed(), Eq(false));
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
+        ASSERT_THAT(q->framedropping_allowed(), Eq(false));
 
         void const* main_compositor = reinterpret_cast<void const*>(0);
         void const* second_compositor = reinterpret_cast<void const*>(1);
         for (int i = 0; i < 20; i++)
         {
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             auto client_id = handle->id();
             handle->release_buffer();
 
-            auto comp_buffer = q.compositor_acquire(main_compositor);
-            auto composited_id = comp_buffer->id();
-            q.compositor_release(comp_buffer);
+            mg::BufferID composited_id;
+            {
+                auto comp_buffer_handle = q->compositor_acquire(main_compositor);
+                composited_id = comp_buffer_handle.buffer()->id();
+            }
 
             EXPECT_THAT(composited_id, Eq(client_id));
 
-            comp_buffer = q.compositor_acquire(second_compositor);
-            EXPECT_THAT(composited_id, Eq(comp_buffer->id()));
-            q.compositor_release(comp_buffer);
+            {
+                auto comp_buffer_handle = q->compositor_acquire(second_compositor);
+                EXPECT_THAT(composited_id, Eq(comp_buffer_handle.buffer()->id()));
+            }
         }
     }
 }
@@ -378,20 +386,21 @@
 /* Regression test for LP: #1210042 */
 TEST_F(BufferQueueTest, clients_dont_recycle_startup_buffer)
 {
-    mc::BufferQueue q(3, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(3, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
-    auto handle = client_acquire_async(q);
+    auto handle = client_acquire_async(*q);
     ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
     auto client_id = handle->id();
     handle->release_buffer();
 
-    handle = client_acquire_async(q);
+    handle = client_acquire_async(*q);
     ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
     handle->release_buffer();
 
-    auto comp_buffer = q.compositor_acquire(this);
-    EXPECT_THAT(client_id, Eq(comp_buffer->id()));
-    q.compositor_release(comp_buffer);
+    auto comp_buffer_handle = q->compositor_acquire(this);
+    EXPECT_THAT(client_id, Eq(comp_buffer_handle.buffer()->id()));
 }
 
 TEST_F(BufferQueueTest, throws_on_out_of_order_client_release)
@@ -418,12 +427,14 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         std::atomic<bool> done(false);
         auto unblock = [&done] { done = true; };
         mt::AutoUnblockThread compositor(unblock,
-            compositor_thread, std::ref(q), std::ref(done));
+            compositor_thread, std::ref(*q), std::ref(done));
 
         std::unordered_set<uint32_t> ids_acquired;
         int const max_ownable_buffers = nbuffers - 1;
@@ -432,7 +443,7 @@
             std::vector<mg::Buffer *> client_buffers;
             for (int acquires = 0; acquires < max_ownable_buffers; ++acquires)
             {
-                auto handle = client_acquire_async(q);
+                auto handle = client_acquire_async(*q);
                 handle->wait_for(std::chrono::seconds(1));
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 ids_acquired.insert(handle->id().as_value());
@@ -441,7 +452,7 @@
 
             for (auto const& buffer : client_buffers)
             {
-                q.client_release(buffer);
+                q->client_release(buffer);
             }
         }
 
@@ -453,17 +464,18 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
         auto client_id = handle->id();
         ASSERT_NO_THROW(handle->release_buffer());
 
-        auto comp_buffer = q.compositor_acquire(this);
-        EXPECT_THAT(client_id, Eq(comp_buffer->id()));
-        EXPECT_NO_THROW(q.compositor_release(comp_buffer));
+        auto comp_buffer_handle = q->compositor_acquire(this);
+        EXPECT_THAT(client_id, Eq(comp_buffer_handle.buffer()->id()));
     }
 }
 
@@ -471,9 +483,11 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
         auto client_id = handle->id();
@@ -482,9 +496,8 @@
         for (int monitor = 0; monitor < 10; monitor++)
         {
             void const* user_id = reinterpret_cast<void const*>(monitor);
-            auto comp_buffer = q.compositor_acquire(user_id);
-            EXPECT_THAT(client_id, Eq(comp_buffer->id()));
-            q.compositor_release(comp_buffer);
+            auto comp_buffer_handle = q->compositor_acquire(user_id);
+            EXPECT_THAT(client_id, Eq(comp_buffer_handle.buffer()->id()));
         }
     }
 }
@@ -493,16 +506,18 @@
 {  // Regression test for LP: #1420678
     for (int nbuffers = 3; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         // Client generates first frame
-        auto handle1 = client_acquire_async(q);
+        auto handle1 = client_acquire_async(*q);
         ASSERT_TRUE(handle1->has_acquired_buffer());
         auto client_id1 = handle1->id();
         handle1->release_buffer();
 
         // Client generates second frame
-        auto handle2 = client_acquire_async(q);
+        auto handle2 = client_acquire_async(*q);
         ASSERT_TRUE(handle2->has_acquired_buffer());
         auto client_id2 = handle2->id();
         handle2->release_buffer();
@@ -511,18 +526,16 @@
         for (int monitor = 0; monitor < 10; monitor++)
         {
             void const* user_id = reinterpret_cast<void const*>(monitor);
-            auto comp_buffer = q.compositor_acquire(user_id);
-            ASSERT_EQ(client_id1, comp_buffer->id());
-            q.compositor_release(comp_buffer);
+            auto comp_buffer_handle = q->compositor_acquire(user_id);
+            ASSERT_EQ(client_id1, comp_buffer_handle.buffer()->id());
         }
 
         // Still many monitors... verify they all get the second frame.
         for (int monitor = 0; monitor < 10; monitor++)
         {
             void const* user_id = reinterpret_cast<void const*>(monitor);
-            auto comp_buffer = q.compositor_acquire(user_id);
-            ASSERT_EQ(client_id2, comp_buffer->id());
-            q.compositor_release(comp_buffer);
+            auto comp_buffer_handle = q->compositor_acquire(user_id);
+            ASSERT_EQ(client_id2, comp_buffer_handle.buffer()->id());
         }
     }
 }
@@ -531,7 +544,9 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         for (int i = 0; i < 10; ++i)
         {
@@ -540,7 +555,7 @@
             int const max_ownable_buffers = nbuffers - 1;
             for (int i = 0; i < max_ownable_buffers; ++i)
             {
-                auto handle = client_acquire_async(q);
+                auto handle = client_acquire_async(*q);
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 buffers.push_back(handle->buffer());
             }
@@ -548,14 +563,13 @@
             for (auto buffer : buffers)
             {
                 client_release_sequence.push_back(buffer->id());
-                q.client_release(buffer);
+                q->client_release(buffer);
             }
 
             for (auto const& client_id : client_release_sequence)
             {
-                auto comp_buffer = q.compositor_acquire(this);
-                EXPECT_THAT(client_id, Eq(comp_buffer->id()));
-                q.compositor_release(comp_buffer);
+                auto comp_buffer_handle = q->compositor_acquire(this);
+                EXPECT_THAT(client_id, Eq(comp_buffer_handle.buffer()->id()));
             }
         }
     }
@@ -565,13 +579,12 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         for (int i = 0; i < 100; i++)
-        {
-            auto buffer = q.compositor_acquire(this);
-            q.compositor_release(buffer);
-        }
+            q->compositor_acquire(this);
     }
 }
 
@@ -579,8 +592,10 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-        q.allow_framedropping(false);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
+        q->allow_framedropping(false);
 
         std::atomic<bool> done(false);
         auto unblock = [&done] { done = true; };
@@ -589,7 +604,7 @@
         {
             for (int nframes = 0; nframes < 100; ++nframes)
             {
-                auto handle = client_acquire_async(q);
+                auto handle = client_acquire_async(*q);
                 handle->wait_for(std::chrono::seconds(1));
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 handle->release_buffer();
@@ -600,10 +615,11 @@
         {
             while (!done)
             {
-                std::shared_ptr<mg::Buffer> buffer;
-                EXPECT_NO_THROW(buffer = q.compositor_acquire(this));
-                EXPECT_THAT(buffer, Ne(nullptr));
-                EXPECT_NO_THROW(q.compositor_release(buffer));
+                {
+                    std::shared_ptr<mg::Buffer> buffer;
+                    EXPECT_NO_THROW(buffer = q->compositor_acquire(this).buffer());
+                    EXPECT_THAT(buffer, Ne(nullptr));
+                }
                 std::this_thread::yield();
             }
         });
@@ -617,7 +633,9 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         mg::Buffer* last_client_acquired_buffer{nullptr};
 
@@ -625,7 +643,7 @@
         {
             if (i % 10 == 0)
             {
-                auto handle = client_acquire_async(q);
+                auto handle = client_acquire_async(*q);
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 last_client_acquired_buffer = handle->buffer();
                 handle->release_buffer();
@@ -634,51 +652,35 @@
             for (int monitor_id = 0; monitor_id < 10; monitor_id++)
             {
                 void const* user_id = reinterpret_cast<void const*>(monitor_id);
-                auto buffer = q.compositor_acquire(user_id);
-                ASSERT_THAT(buffer.get(), Eq(last_client_acquired_buffer));
-                q.compositor_release(buffer);
+                auto buffer_handle = q->compositor_acquire(user_id);
+                ASSERT_THAT(buffer_handle.buffer().get(), Eq(last_client_acquired_buffer));
             }
         }
     }
 }
 
-TEST_F(BufferQueueTest, compositor_release_verifies_parameter)
-{
-    for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
-    {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-
-        auto handle = client_acquire_async(q);
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-        handle->release_buffer();
-
-        auto comp_buffer = q.compositor_acquire(this);
-        q.compositor_release(comp_buffer);
-        EXPECT_THROW(q.compositor_release(comp_buffer), std::logic_error);
-    }
-}
-
 /* Regression test for LP#1270964 */
 TEST_F(BufferQueueTest, compositor_client_interleaved)
 {
-    mc::BufferQueue q(3, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(3, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
-    auto handle = client_acquire_async(q);
+    auto handle = client_acquire_async(*q);
     ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
     auto first_ready_buffer_id = handle->id();
     handle->release_buffer();
 
-    handle = client_acquire_async(q);
+    handle = client_acquire_async(*q);
     ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
     // in the original bug, compositor would be given the wrong buffer here
-    auto compositor_buffer = q.compositor_acquire(this);
+    auto compositor_buffer_handle = q->compositor_acquire(this);
 
-    EXPECT_THAT(compositor_buffer->id(), Eq(first_ready_buffer_id));
+    EXPECT_THAT(compositor_buffer_handle.buffer()->id(), Eq(first_ready_buffer_id));
 
     handle->release_buffer();
-    q.compositor_release(compositor_buffer);
 }
 
 TEST_F(BufferQueueTest, overlapping_compositors_get_different_frames)
@@ -686,36 +688,42 @@
     // This test simulates bypass behaviour
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-
-        std::shared_ptr<mg::Buffer> compositor[2];
-
-        auto handle = client_acquire_async(q);
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-        handle->release_buffer();
-        compositor[0] = q.compositor_acquire(this);
-
-        handle = client_acquire_async(q);
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-        handle->release_buffer();
-        compositor[1] = q.compositor_acquire(this);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
+
+        mc::BufferHandle *compositor[] =
+            { new mc::BufferHandle(nullptr, nullptr),
+              new mc::BufferHandle(nullptr, nullptr) };
+
+        auto handle = client_acquire_async(*q);
+        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
+        handle->release_buffer();
+        *compositor[0] = q->compositor_acquire(this);
+
+        handle = client_acquire_async(*q);
+        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
+        handle->release_buffer();
+        *compositor[1] = q->compositor_acquire(this);
 
         for (int i = 0; i < 20; i++)
         {
             // Two compositors acquired, and they're always different...
-            ASSERT_THAT(compositor[0]->id(), Ne(compositor[1]->id()));
-
+            ASSERT_THAT(compositor[0]->buffer()->id(), Ne(compositor[1]->buffer()->id()));
             // One of the compositors (the oldest one) gets a new buffer...
             int oldest = i & 1;
-            q.compositor_release(compositor[oldest]);
-            auto handle = client_acquire_async(q);
+            delete compositor[oldest];
+            compositor[oldest] = nullptr;
+            auto handle = client_acquire_async(*q);
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             handle->release_buffer();
-            compositor[oldest] = q.compositor_acquire(this);
+            compositor[oldest] = new mc::BufferHandle(nullptr, nullptr);
+            *compositor[oldest] = q->compositor_acquire(this);
         }
 
-        q.compositor_release(compositor[0]);
-        q.compositor_release(compositor[1]);
+        for (int i = 0; i < 2; i++)
+            if (compositor[i])
+                delete compositor[i];
     }
 }
 
@@ -723,13 +731,14 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        auto comp_buffer = q.compositor_acquire(this);
-        auto snapshot = q.snapshot_acquire();
-        EXPECT_THAT(snapshot->id(), Eq(comp_buffer->id()));
-        q.compositor_release(comp_buffer);
-        q.snapshot_release(snapshot);
+        auto comp_buffer_handle = q->compositor_acquire(this);
+        auto snapshot_handle = q->snapshot_acquire();
+        EXPECT_THAT(snapshot_handle.buffer()->id(),
+                    Eq(comp_buffer_handle.buffer()->id()));
     }
 }
 
@@ -744,13 +753,16 @@
 
 TEST_F(BufferQueueTest, callbacks_cant_happen_after_shutdown_with_snapshots)
 {
-    mc::BufferQueue q(1, allocator, basic_properties, policy_factory);
-
-    auto snapshot = q.snapshot_acquire();
-    q.drop_client_requests();
-    q.snapshot_release(snapshot);
-
-    auto client = client_acquire_async(q);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(1, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
+
+    {
+        auto snapshot = q->snapshot_acquire();
+        q->drop_client_requests();
+    }
+
+    auto client = client_acquire_async(*q);
     ASSERT_FALSE(client->has_acquired_buffer());
 }
 
@@ -758,39 +770,19 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
         int const num_snapshots = 100;
 
-        std::shared_ptr<mg::Buffer> buf[num_snapshots];
-        for (int i = 0; i < num_snapshots; i++)
-            buf[i] = q.snapshot_acquire();
-
-        for (int i = 0; i < num_snapshots; i++)
-            q.snapshot_release(buf[i]);
-    }
-}
-
-TEST_F(BufferQueueTest, snapshot_release_verifies_parameter)
-{
-    for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
-    {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-
-        auto handle = client_acquire_async(q);
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-        handle->release_buffer();
-
-        auto comp_buffer = q.compositor_acquire(this);
-        EXPECT_THROW(q.snapshot_release(comp_buffer), std::logic_error);
-
-        handle = client_acquire_async(q);
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-        auto snapshot = q.snapshot_acquire();
-
-        EXPECT_THAT(snapshot->id(), Eq(comp_buffer->id()));
-        EXPECT_THAT(snapshot->id(), Ne(handle->id()));
-        EXPECT_NO_THROW(q.snapshot_release(snapshot));
-        EXPECT_THROW(q.snapshot_release(snapshot), std::logic_error);
+        std::vector<mc::BufferHandle> bufs;
+        bufs.reserve(num_snapshots);
+
+        for (int i = 0; i < num_snapshots; i++)
+            bufs.push_back(std::move(mc::BufferHandle(nullptr, nullptr)));
+
+        for (int i = 0; i < num_snapshots; i++)
+            bufs[i] = q->snapshot_acquire();
     }
 }
 
@@ -798,31 +790,33 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         std::atomic<bool> done(false);
 
         auto unblock = [&done]{ done = true;};
 
         mt::AutoUnblockThread compositor(unblock, compositor_thread,
-                                         std::ref(q),
+                                         std::ref(*q),
                                          std::ref(done));
         mt::AutoUnblockThread snapshotter1(unblock, snapshot_thread,
-                                           std::ref(q),
+                                           std::ref(*q),
                                            std::ref(done));
         mt::AutoUnblockThread snapshotter2(unblock, snapshot_thread,
-                                           std::ref(q),
+                                           std::ref(*q),
                                            std::ref(done));
 
-        q.allow_framedropping(false);
-        mt::AutoJoinThread client1(client_thread, std::ref(q), 1000);
+        q->allow_framedropping(false);
+        mt::AutoJoinThread client1(client_thread, std::ref(*q), 1000);
         client1.stop();
 
-        q.allow_framedropping(true);
-        mt::AutoJoinThread client2(client_thread, std::ref(q), 1000);
+        q->allow_framedropping(true);
+        mt::AutoJoinThread client2(client_thread, std::ref(*q), 1000);
         client2.stop();
 
-        mt::AutoJoinThread client3(switching_client_thread, std::ref(q), 1000);
+        mt::AutoJoinThread client3(switching_client_thread, std::ref(*q), 1000);
         client3.stop();
     }
 }
@@ -878,11 +872,13 @@
 {
     for (int nbuffers = 2; nbuffers <= 3; nbuffers++)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
         unsigned long client_frames = 0;
         const unsigned long compose_frames = 20;
 
-        q.allow_framedropping(false);
+        q->allow_framedropping(false);
 
         std::atomic<bool> done(false);
 
@@ -892,8 +888,7 @@
             {
                 std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
-                auto buf = q.compositor_acquire(this);
-                q.compositor_release(buf);
+                q->compositor_acquire(this);
 
                 if (frame == compose_frames)
                 {
@@ -905,13 +900,13 @@
             }
         });
 
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
         handle->release_buffer();
 
         while (!done.load())
         {
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             handle->wait_for(std::chrono::seconds(1));
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             handle->release_buffer();
@@ -934,12 +929,14 @@
      */
     for (int nbuffers = 3; nbuffers <= 3; nbuffers++)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
         unsigned long client_frames = 0;
         unsigned long const compose_frames = 100;
         auto const frame_time = std::chrono::milliseconds(16);
 
-        q.allow_framedropping(false);
+        q->allow_framedropping(false);
 
         std::atomic<bool> done(false);
         std::mutex sync;
@@ -950,8 +947,7 @@
             {
                 std::this_thread::sleep_for(frame_time);
                 sync.lock();
-                auto buf = q.compositor_acquire(this);
-                q.compositor_release(buf);
+                q->compositor_acquire(this);
                 sync.unlock();
 
                 if (frame == compose_frames)
@@ -964,7 +960,7 @@
             }
         });
 
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
         handle->release_buffer();
 
@@ -972,7 +968,7 @@
         {
             sync.lock();
             sync.unlock();
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             handle->wait_for(std::chrono::seconds(1));
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             std::this_thread::sleep_for(frame_time);
@@ -992,7 +988,9 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         for (int width = 1; width < 100; ++width)
         {
@@ -1000,16 +998,15 @@
 
             for (int subframe = 0; subframe < 3; ++subframe)
             {
-                q.resize(expect_size);
-                auto handle = client_acquire_async(q);
+                q->resize(expect_size);
+                auto handle = client_acquire_async(*q);
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 auto buffer = handle->buffer();
                 ASSERT_THAT(expect_size, Eq(buffer->size()));
                 handle->release_buffer();
 
-                auto comp_buffer = q.compositor_acquire(this);
-                ASSERT_THAT(expect_size, Eq(comp_buffer->size()));
-                q.compositor_release(comp_buffer);
+                auto comp_buffer_handle = q->compositor_acquire(this);
+                ASSERT_THAT(expect_size, Eq(comp_buffer_handle.buffer()->size()));
             }
         }
     }
@@ -1027,7 +1024,9 @@
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
         std::vector<mg::BufferID> history;
 
         const int width0 = 123;
@@ -1036,7 +1035,7 @@
         const int dy = -3;
         int width = width0;
         int height = height0;
-        int const nbuffers_to_use = q.buffers_free_for_client();
+        int const nbuffers_to_use = q->buffers_free_for_client();
         ASSERT_THAT(nbuffers_to_use, Gt(0));
 
         int max_buffers{max_ownable_buffers(nbuffers)};
@@ -1046,8 +1045,8 @@
             width += dx;
             height += dy;
 
-            q.resize(new_size);
-            auto handle = client_acquire_async(q);
+            q->resize(new_size);
+            auto handle = client_acquire_async(*q);
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             history.emplace_back(handle->id());
             auto buffer = handle->buffer();
@@ -1065,25 +1064,22 @@
             width += dx;
             height += dy;
 
-            auto buffer = q.compositor_acquire(this);
+            auto buffer_handle = q->compositor_acquire(this);
 
             // Verify the compositor gets resized buffers, eventually
-            ASSERT_THAT(buffer->size(), Eq(expect_size));
+            ASSERT_THAT(buffer_handle.buffer()->size(), Eq(expect_size));
 
             // Verify the compositor gets buffers with *contents*, ie. that
             // they have not been resized prematurely and are empty.
-            ASSERT_THAT(history[consume], Eq(buffer->id()));
-
-            q.compositor_release(buffer);
+            ASSERT_THAT(history[consume], Eq(buffer_handle.buffer()->id()));
         }
 
         // Verify the final buffer size sticks
         const geom::Size final_size{width - dx, height - dy};
         for (int unchanging = 0; unchanging < 100; ++unchanging)
         {
-            auto buffer = q.compositor_acquire(this);
-            ASSERT_THAT(buffer->size(), Eq(final_size));
-            q.compositor_release(buffer);
+            auto buffer_handle = q->compositor_acquire(this);
+            ASSERT_THAT(buffer_handle.buffer()->size(), Eq(final_size));
         }
     }
 }
@@ -1093,23 +1089,22 @@
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
         mtd::MockFrameDroppingPolicyFactory policy_factory;
-        mc::BufferQueue q(nbuffers,
-                          allocator,
-                          basic_properties,
-                          policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        auto first = client_acquire_sync(q);
-        q.client_release(first);
+        auto first = client_acquire_sync(*q);
+        q->client_release(first);
 
         // Start rendering one (don't finish)
-        auto d = q.compositor_acquire(nullptr);
-        ASSERT_EQ(first, d.get());
+        auto d = q->compositor_acquire(nullptr);
+        ASSERT_EQ(first, d.buffer().get());
 
-        auto second = client_acquire_sync(q);
-        q.client_release(second);
+        auto second = client_acquire_sync(*q);
+        q->client_release(second);
 
         // Client waits for a new frame
-        auto end = client_acquire_async(q);
+        auto end = client_acquire_async(*q);
 
         // Surface goes offscreen or occluded; trigger a timeout
         policy_factory.trigger_policies();
@@ -1121,8 +1116,6 @@
         // will produce another frame.
         if (end->has_acquired_buffer())
             ASSERT_NE(second, end->buffer());
-
-        q.compositor_release(d);
     }
 }
 
@@ -1130,34 +1123,33 @@
 {  // Second regression test for LP: #1396006, LP: #1379685
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers,
-                          allocator,
-                          basic_properties,
-                          policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        q.allow_framedropping(true);
+        q->allow_framedropping(true);
 
         // Fill 'er up
         std::vector<mg::Buffer*> order;
         for (int f = 0; f < nbuffers; ++f)
         {
-            auto b = client_acquire_sync(q);
+            auto b = client_acquire_sync(*q);
             order.push_back(b);
-            q.client_release(b);
+            q->client_release(b);
         }
 
         // Composite all but one
         std::vector<std::shared_ptr<mg::Buffer>> compositing;
         for (int n = 0; n < nbuffers-1; ++n)
         {
-            auto c = q.compositor_acquire(nullptr);
-            compositing.push_back(c);
-            ASSERT_EQ(order[n], c.get());
+            auto c = q->compositor_acquire(nullptr);
+            compositing.push_back(c.buffer());
+            ASSERT_EQ(order[n], c.buffer().get());
         }
 
         // Ensure it's not the newest frame that gets dropped to satisfy the
         // client.
-        auto end = client_acquire_async(q);
+        auto end = client_acquire_async(*q);
 
         // The queue could solve this problem a few ways. It might choose to
         // defer framedropping till it's safe, or even allocate additional
@@ -1203,25 +1195,24 @@
          nbuffers++)
     {
         mtd::MockFrameDroppingPolicyFactory policy_factory;
-        mc::BufferQueue q(nbuffers,
-                          allocator,
-                          basic_properties,
-                          policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         for (int i = 0; i < max_ownable_buffers(nbuffers); i++)
         {
-            auto client = client_acquire_sync(q);
-            q.client_release(client);
+            auto client = client_acquire_sync(*q);
+            q->client_release(client);
         }
 
         /* Queue up two pending swaps */
-        auto first_swap = client_acquire_async(q);
-        auto second_swap = client_acquire_async(q);
+        auto first_swap = client_acquire_async(*q);
+        auto second_swap = client_acquire_async(*q);
 
         ASSERT_FALSE(first_swap->has_acquired_buffer());
         ASSERT_FALSE(second_swap->has_acquired_buffer());
 
-        q.compositor_acquire(nullptr);
+        q->compositor_acquire(nullptr);
 
         EXPECT_TRUE(first_swap->has_acquired_buffer());
         EXPECT_FALSE(second_swap->has_acquired_buffer());
@@ -1241,48 +1232,54 @@
     int const nbuffers{1};
     geom::Size const new_size{123,456};
 
-    mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-
-    q.client_release(client_acquire_sync(q));
-    q.resize(new_size);
-
-    auto const handle = client_acquire_async(q);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
+
+    q->client_release(client_acquire_sync(*q));
+    q->resize(new_size);
+
+    auto const handle = client_acquire_async(*q);
     EXPECT_THAT(handle->has_acquired_buffer(), Eq(false));
 
-    auto buf = q.compositor_acquire(this);
-    q.compositor_release(buf);
+    q->compositor_acquire(this);
 
-    buf = q.compositor_acquire(this);
-    EXPECT_THAT(buf->size(), Eq(new_size));
-    q.compositor_release(buf);
+    {
+        auto buf_handle = q->compositor_acquire(this);
+        EXPECT_THAT(buf_handle.buffer()->size(), Eq(new_size));
+    }
 }
 
 TEST_F(BufferQueueTest, double_buffered_client_is_not_blocked_prematurely)
 {  // Regression test for LP: #1319765
     using namespace testing;
 
-    mc::BufferQueue q{2, allocator, basic_properties, policy_factory};
-
-    q.client_release(client_acquire_sync(q));
-    auto a = q.compositor_acquire(this);
-    q.client_release(client_acquire_sync(q));
-    auto b = q.compositor_acquire(this);
-
-    ASSERT_NE(a.get(), b.get());
-
-    q.compositor_release(a);
-    q.client_release(client_acquire_sync(q));
-
-    q.compositor_release(b);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(2, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
+
+    q->client_release(client_acquire_sync(*q));
+    auto a = new mc::BufferHandle(nullptr, nullptr);
+    *a = q->compositor_acquire(this);
+    q->client_release(client_acquire_sync(*q));
+    auto b = new mc::BufferHandle(nullptr, nullptr);
+    *b = q->compositor_acquire(this);
+
+    ASSERT_NE(a->buffer().get(), b->buffer().get());
+    delete a;
+
+    q->client_release(client_acquire_sync(*q));
+
+    delete b;
 
     /*
      * Update to the original test case; This additional compositor acquire
      * represents the fixing of LP: #1395581 in the compositor logic.
      */
-    if (q.buffers_ready_for_compositor(this))
-        q.compositor_release(q.compositor_acquire(this));
+    if (q->buffers_ready_for_compositor(this))
+        q->compositor_acquire(this);
 
-    auto handle = client_acquire_async(q);
+    auto handle = client_acquire_async(*q);
     // With the fix, a buffer will be available instantaneously:
     ASSERT_TRUE(handle->has_acquired_buffer());
     handle->release_buffer();
@@ -1292,45 +1289,49 @@
 {  // Extended regression test for LP: #1319765
     using namespace testing;
 
-    mc::BufferQueue q{2, allocator, basic_properties, policy_factory};
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(2, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
     for (int i = 0; i < 100; ++i)
     {
-        auto x = client_acquire_async(q);
+        auto x = client_acquire_async(*q);
         ASSERT_TRUE(x->has_acquired_buffer());
         x->release_buffer();
 
-        auto a = q.compositor_acquire(this);
+        auto a = new mc::BufferHandle(nullptr, nullptr);
+        *a = q->compositor_acquire(this);
 
-        auto y = client_acquire_async(q);
+        auto y = client_acquire_async(*q);
         ASSERT_TRUE(y->has_acquired_buffer());
         y->release_buffer();
 
-        auto b = q.compositor_acquire(this);
-    
-        ASSERT_NE(a.get(), b.get());
-    
-        q.compositor_release(a);
-
-        auto w = client_acquire_async(q);
+        auto b = new mc::BufferHandle(nullptr, nullptr);
+        *b = q->compositor_acquire(this);
+    
+        ASSERT_NE(a->buffer(), b->buffer());
+
+        delete a;
+
+        auto w = client_acquire_async(*q);
         ASSERT_TRUE(w->has_acquired_buffer());
         w->release_buffer();
-    
-        q.compositor_release(b);
+
+        delete b;
 
         /*
          * Update to the original test case; This additional compositor acquire
          * represents the fixing of LP: #1395581 in the compositor logic.
          */
-        if (q.buffers_ready_for_compositor(this))
-            q.compositor_release(q.compositor_acquire(this));
+        if (q->buffers_ready_for_compositor(this))
+            q->compositor_acquire(this);
 
-        auto z = client_acquire_async(q);
+        auto z = client_acquire_async(*q);
         ASSERT_TRUE(z->has_acquired_buffer());
         z->release_buffer();
 
-        q.compositor_release(q.compositor_acquire(this));
-        q.compositor_release(q.compositor_acquire(this));
+        q->compositor_acquire(this);
+        q->compositor_acquire(this);
     }
 }
 
@@ -1340,34 +1341,40 @@
  
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q{nbuffers, allocator, basic_properties, policy_factory};
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
     
         // Produce frame 1
-        q.client_release(client_acquire_sync(q));
+        q->client_release(client_acquire_sync(*q));
         // Acquire frame 1
-        auto a = q.compositor_acquire(this);
+        auto a = new mc::BufferHandle(nullptr, nullptr);
+        *a = q->compositor_acquire(this);
     
         // Produce frame 2
-        q.client_release(client_acquire_sync(q));
+        q->client_release(client_acquire_sync(*q));
         // Acquire frame 2
-        auto b = q.compositor_acquire(this);
+        auto b = new mc::BufferHandle(nullptr, nullptr);
+        *b = q->compositor_acquire(this);
     
         // Release frame 1
-        q.compositor_release(a);
+        delete a;
+
         // Produce frame 3
-        q.client_release(client_acquire_sync(q));
+        q->client_release(client_acquire_sync(*q));
         // Release frame 2
-        q.compositor_release(b);
+        delete b;
     
         // Verify frame 3 is ready for the first compositor
-        ASSERT_THAT(q.buffers_ready_for_compositor(this), Ge(1));
-        auto c = q.compositor_acquire(this);
+        ASSERT_THAT(q->buffers_ready_for_compositor(this), Ge(1));
+        auto c = new mc::BufferHandle(nullptr, nullptr);
+        *c = q->compositor_acquire(this);
 
         // Verify frame 3 is ready for a second compositor
         int const that = 0;
-        ASSERT_THAT(q.buffers_ready_for_compositor(&that), Ge(1));
+        ASSERT_THAT(q->buffers_ready_for_compositor(&that), Ge(1));
 
-        q.compositor_release(c);
+        delete c;
     }
 }
 
@@ -1377,25 +1384,27 @@
  
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q{nbuffers, allocator, basic_properties, policy_factory};
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
     
         const int nmonitors = 3;
         int monitor[nmonitors];
 
         for (int m = 0; m < nmonitors; ++m)
         {
-            ASSERT_EQ(0, q.buffers_ready_for_compositor(&monitor[m]));
+            ASSERT_EQ(0, q->buffers_ready_for_compositor(&monitor[m]));
         }
 
         // Produce a frame
-        q.client_release(client_acquire_sync(q));
+        q->client_release(client_acquire_sync(*q));
 
         // Consume
         for (int m = 0; m < nmonitors; ++m)
         {
-            ASSERT_EQ(1, q.buffers_ready_for_compositor(&monitor[m]));
-            q.compositor_release(q.compositor_acquire(&monitor[m]));
-            ASSERT_EQ(0, q.buffers_ready_for_compositor(&monitor[m]));
+            ASSERT_EQ(1, q->buffers_ready_for_compositor(&monitor[m]));
+            q->compositor_acquire(&monitor[m]);
+            ASSERT_EQ(0, q->buffers_ready_for_compositor(&monitor[m]));
         }
     }
 }
@@ -1407,47 +1416,47 @@
 
     int const nbuffers{3};
 
-    mc::BufferQueue q{nbuffers, allocator, basic_properties, policy_factory};
-    q.allow_framedropping(true);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
+    q->allow_framedropping(true);
 
-    std::vector<std::shared_ptr<mg::Buffer>> buffers;
+    std::vector<mc::BufferHandle> buffer_handles;
 
     /* The client can never own this acquired buffer */
-    auto comp_buffer = q.compositor_acquire(this);
-    buffers.push_back(comp_buffer);
+    auto comp_buffer_handle = q->compositor_acquire(this);
+    auto id_from_comp = comp_buffer_handle.buffer()->id();
+    buffer_handles.push_back(std::move(comp_buffer_handle));
 
     /* Let client release all possible buffers so they go into
      * the ready queue
      */
     for (int i = 0; i < nbuffers; ++i)
     {
-        auto handle = client_acquire_async(q);
+        auto handle = client_acquire_async(*q);
         ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
         /* Check the client never got the compositor buffer acquired above */
-        ASSERT_THAT(handle->id(), Ne(comp_buffer->id()));
+        ASSERT_THAT(handle->id(), Ne(id_from_comp));
         handle->release_buffer();
     }
 
     /* Let the compositor acquire all ready buffers */
     for (int i = 0; i < nbuffers; ++i)
-    {
-        buffers.push_back(q.compositor_acquire(this));
-    }
+        buffer_handles.push_back(q->compositor_acquire(this));
 
     /* At this point the queue has 0 free buffers and 0 ready buffers
      * so the next client request should not be satisfied until
      * a compositor releases its buffers */
-    auto handle = client_acquire_async(q);
+    auto handle = client_acquire_async(*q);
     /* ... unless the BufferQueue is overallocating. In that case it will
      * have succeeding in acquiring immediately.
      */ 
     if (!handle->has_acquired_buffer())
     {
         /* Release compositor buffers so that the client can get one */
-        for (auto const& buffer : buffers)
-        {
-            q.compositor_release(buffer);
-        }
+        for (auto& buf_handle : buffer_handles)
+            buf_handle = std::move(mc::BufferHandle(nullptr, nullptr));
+
         EXPECT_THAT(handle->has_acquired_buffer(), Eq(true));
     }
 }
@@ -1458,7 +1467,9 @@
 
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         std::mutex client_buffer_guard;
         std::condition_variable client_buffer_cv;
@@ -1470,7 +1481,7 @@
         {
             while (!done)
             {
-                auto buffer = q.compositor_acquire(this);
+                auto buffer_handle = q->compositor_acquire(this);
 
                 {
                     std::unique_lock<std::mutex> lock(client_buffer_guard);
@@ -1480,18 +1491,17 @@
                         time_for_client_to_acquire,
                         [&]()->bool{ return client_buffer; }))
                     {
-                        ASSERT_THAT(buffer->id(), Ne(client_buffer->id()));
+                        ASSERT_THAT(buffer_handle.buffer()->id(), Ne(client_buffer->id()));
                     }
                 }
 
                 std::this_thread::yield();
-                q.compositor_release(buffer);
             }
         });
 
         for (int i = 0; i < 1000; ++i)
         {
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             handle->wait_for(std::chrono::seconds(1));
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
@@ -1514,30 +1524,35 @@
 {
     for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
+
         for (int i = 0; i < 100; ++i)
         {
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
 
             auto client_id = handle->id();
-            std::vector<std::shared_ptr<mg::Buffer>> buffers;
+            std::vector<mc::BufferHandle*> buffer_handles;
             for (int j = 0; j < nbuffers; j++)
             {
-                auto buffer = q.compositor_acquire(this);
-                ASSERT_THAT(client_id, Ne(buffer->id()));
-                buffers.push_back(buffer);
+                auto buffer_handle_ptr = new mc::BufferHandle(nullptr, nullptr);
+                *buffer_handle_ptr = q->compositor_acquire(this);
+                ASSERT_THAT(client_id, Ne(buffer_handle_ptr->buffer()->id()));
+                buffer_handles.push_back(buffer_handle_ptr);
             }
 
-            for (auto const& buffer: buffers)
-                q.compositor_release(buffer);
+            for (auto& buf_handle: buffer_handles)
+                delete buf_handle;
 
             handle->release_buffer();
 
-            /* Flush out one ready buffer */
-            auto buffer = q.compositor_acquire(this);
-            ASSERT_THAT(client_id, Eq(buffer->id()));
-            q.compositor_release(buffer);
+            {
+                /* Flush out one ready buffer */
+                auto buffer_handle = q->compositor_acquire(this);
+                ASSERT_THAT(client_id, Eq(buffer_handle.buffer()->id()));
+            }
         }
     }
 }
@@ -1550,36 +1565,36 @@
 {
     for (int nbuffers = 3; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
         void const* main_compositor = reinterpret_cast<void const*>(0);
         void const* second_compositor = reinterpret_cast<void const*>(1);
 
-        /* Hold a reference to current compositor buffer*/
-        auto comp_buffer1 = q.compositor_acquire(main_compositor);
+        auto comp_buffer1 = new mc::BufferHandle(nullptr, nullptr);
+        *comp_buffer1 = q->compositor_acquire(main_compositor);
 
-        int const prefill = q.buffers_free_for_client();
+        int const prefill = q->buffers_free_for_client();
         ASSERT_THAT(prefill, Gt(0));
         for (int acquires = 0; acquires < prefill; ++acquires)
         {
-            auto handle = client_acquire_async(q);
+            auto handle = client_acquire_async(*q);
             ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
             handle->release_buffer();
         }
 
         /* Have a second compositor advance the current compositor buffer at least twice */
         for (int acquires = 0; acquires < nbuffers; ++acquires)
-        {
-            auto comp_buffer = q.compositor_acquire(second_compositor);
-            q.compositor_release(comp_buffer);
-        }
-        q.compositor_release(comp_buffer1);
+            q->compositor_acquire(second_compositor);
+
+        delete comp_buffer1;
 
         /* An async client should still be able to cycle through all the available buffers */
         std::atomic<bool> done(false);
         auto unblock = [&done] { done = true; };
         mt::AutoUnblockThread compositor(unblock,
-           compositor_thread, std::ref(q), std::ref(done));
+           compositor_thread, std::ref(*q), std::ref(done));
 
         std::unordered_set<mg::Buffer *> unique_buffers_acquired;
         int const max_ownable_buffers = nbuffers - 1;
@@ -1588,7 +1603,7 @@
             std::vector<mg::Buffer *> client_buffers;
             for (int acquires = 0; acquires < max_ownable_buffers; ++acquires)
             {
-                auto handle = client_acquire_async(q);
+                auto handle = client_acquire_async(*q);
                 handle->wait_for(std::chrono::seconds(1));
                 ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
                 unique_buffers_acquired.insert(handle->buffer());
@@ -1597,7 +1612,7 @@
 
             for (auto const& buffer : client_buffers)
             {
-                q.client_release(buffer);
+                q->client_release(buffer);
             }
         }
 
@@ -1666,54 +1681,63 @@
             q.client_release(client_acquire_sync(q));
         }};
 
-    auto b = q.compositor_acquire(this);
-    q.compositor_release(b);
+    q.compositor_acquire(this);
 }
 
 TEST_F(BufferQueueTest, first_user_is_recorded)
 {
     for (int nbuffers = 1; nbuffers <= max_nbuffers_to_test; ++nbuffers)
     {
-        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+        std::shared_ptr<mc::BufferQueue> q;
+        ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+        ASSERT_THAT(q, Ne(nullptr));
 
-        auto comp = q.compositor_acquire(this);
-        EXPECT_TRUE(q.is_a_current_buffer_user(this));
-        q.compositor_release(comp);
+        {
+            auto comp = q->compositor_acquire(this);
+            EXPECT_TRUE(q->is_a_current_buffer_user(this));
+        }
     }
 }
 
 TEST_F(BufferQueueTest, gives_compositor_a_valid_buffer_after_dropping_old_buffers_without_clients)
 {
     int const nbuffers = 3;
-    mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
-
-    q.drop_old_buffers();
-
-    auto comp = q.compositor_acquire(this);
-    ASSERT_THAT(comp, Ne(nullptr));
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
+
+    q->drop_old_buffers();
+
+    auto comp = q->compositor_acquire(this);
+    ASSERT_THAT(comp.buffer(), Ne(nullptr));
 }
 
 TEST_F(BufferQueueTest, gives_compositor_the_newest_buffer_after_dropping_old_buffers)
 {
     int const nbuffers = 3;
-    mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
-    auto handle1 = client_acquire_async(q);
+    auto handle1 = client_acquire_async(*q);
     ASSERT_THAT(handle1->has_acquired_buffer(), Eq(true));
     handle1->release_buffer();
 
-    auto handle2 = client_acquire_async(q);
+    auto handle2 = client_acquire_async(*q);
     ASSERT_THAT(handle2->has_acquired_buffer(), Eq(true));
     handle2->release_buffer();
 
-    q.drop_old_buffers();
-
-    auto comp = q.compositor_acquire(this);
-    ASSERT_THAT(comp->id(), Eq(handle2->id()));
-    q.compositor_release(comp);
-
-    comp = q.compositor_acquire(this);
-    ASSERT_THAT(comp->id(), Eq(handle2->id()));
+    q->drop_old_buffers();
+
+    {
+        auto buffer_handle = q->compositor_acquire(this);
+        ASSERT_THAT(buffer_handle.buffer()->id(), Eq(handle2->id()));
+    }
+
+    {
+        auto buffer_handle = q->compositor_acquire(this);
+        ASSERT_THAT(buffer_handle.buffer()->id(), Eq(handle2->id()));
+    }
 }
 
 TEST_F(BufferQueueTest, gives_new_compositor_the_newest_buffer_after_dropping_old_buffers)
@@ -1721,22 +1745,25 @@
     int const nbuffers = 3;
     void const* const new_compositor_id{&nbuffers};
 
-    mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
+    std::shared_ptr<mc::BufferQueue> q;
+    ASSERT_NO_THROW(q = std::make_shared<mc::BufferQueue>(nbuffers, allocator, basic_properties, policy_factory));
+    ASSERT_THAT(q, Ne(nullptr));
 
-    auto handle1 = client_acquire_async(q);
+    auto handle1 = client_acquire_async(*q);
     ASSERT_THAT(handle1->has_acquired_buffer(), Eq(true));
     handle1->release_buffer();
 
-    auto comp = q.compositor_acquire(this);
-    ASSERT_THAT(comp->id(), Eq(handle1->id()));
-    q.compositor_release(comp);
+    {
+        auto buffer_handle = q->compositor_acquire(this);
+        ASSERT_THAT(buffer_handle.buffer()->id(), Eq(handle1->id()));
+    }
 
-    auto handle2 = client_acquire_async(q);
+    auto handle2 = client_acquire_async(*q);
     ASSERT_THAT(handle2->has_acquired_buffer(), Eq(true));
     handle2->release_buffer();
 
-    q.drop_old_buffers();
+    q->drop_old_buffers();
 
-    auto comp2 = q.compositor_acquire(new_compositor_id);
-    ASSERT_THAT(comp2->id(), Eq(handle2->id()));
+    auto buffer_handle2 = q->compositor_acquire(new_compositor_id);
+    ASSERT_THAT(buffer_handle2.buffer()->id(), Eq(handle2->id()));
 }
 
=== removed file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	1970-01-01 00:00:00 +0000
@@ -1,194 +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 "src/server/compositor/buffer_stream_surfaces.h"
-
-#include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/mock_buffer_bundle.h"
-#include "mir_test/gmock_fixes.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <condition_variable>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-
-class BufferStreamTest : public ::testing::Test
-{
-protected:
-    BufferStreamTest()
-    {
-        mock_buffer = std::make_shared<mtd::StubBuffer>();
-        mock_bundle = std::make_shared<mtd::MockBufferBundle>();
-
-        // Two of the tests care about this, the rest should not...
-        EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-            .Times(::testing::AnyNumber());
-    }
-
-    std::shared_ptr<mtd::StubBuffer> mock_buffer;
-    std::shared_ptr<mtd::MockBufferBundle> mock_bundle;
-};
-
-TEST_F(BufferStreamTest, size_query)
-{
-    geom::Size size{4, 5};
-    mg::BufferProperties properties {size, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware};
-    EXPECT_CALL(*mock_bundle, properties())
-        .Times(1)
-        .WillOnce(testing::Return(properties));
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    auto returned_size = buffer_stream.stream_size();
-    EXPECT_EQ(size, returned_size);
-}
-
-TEST_F(BufferStreamTest, pixel_format_query)
-{
-    MirPixelFormat format{mir_pixel_format_abgr_8888};
-    mg::BufferProperties properties {geom::Size{4, 5}, format, mg::BufferUsage::hardware};
-    EXPECT_CALL(*mock_bundle, properties())
-        .Times(1)
-        .WillOnce(testing::Return(properties));
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    auto returned_pf = buffer_stream.get_stream_pixel_format();
-    EXPECT_EQ(format, returned_pf);
-}
-
-TEST_F(BufferStreamTest, force_requests_to_complete)
-{
-    EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-        .Times(2);  // Once explcit, once on destruction
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    buffer_stream.force_requests_to_complete();
-}
-
-TEST_F(BufferStreamTest, requests_are_completed_before_destruction)
-{
-    EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-}
-
-TEST_F(BufferStreamTest, get_buffer_for_compositor_handles_resources)
-{
-    using namespace testing;
-
-    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
-        .Times(1)
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_bundle, compositor_release(_))
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-
-    buffer_stream.lock_compositor_buffer(0);
-}
-
-TEST_F(BufferStreamTest, get_buffer_for_compositor_can_lock)
-{
-    using namespace testing;
-
-    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
-        .Times(1)
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_bundle, compositor_release(_))
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-
-    buffer_stream.lock_compositor_buffer(0);
-}
-
-TEST_F(BufferStreamTest, get_buffer_for_client_releases_resources)
-{
-    std::mutex mutex;
-    std::condition_variable cv;
-    mg::Buffer* buffer{nullptr};
-    bool done = false;
-
-    auto const callback =
-        [&](mg::Buffer* new_buffer)
-        {
-           std::unique_lock<decltype(mutex)> lock(mutex);
-           buffer = new_buffer;
-           done = true;
-           cv.notify_one();
-        };
-
-    using namespace testing;
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-
-    InSequence seq;
-    EXPECT_CALL(*mock_bundle, client_acquire(_))
-        .Times(1)
-        .WillOnce(InvokeArgument<0>(mock_buffer.get()));
-    EXPECT_CALL(*mock_bundle, client_release(_))
-        .Times(1);
-    EXPECT_CALL(*mock_bundle, client_acquire(_))
-        .Times(1)
-        .WillOnce(InvokeArgument<0>(mock_buffer.get()));
-
-    buffer_stream.acquire_client_buffer(callback);
-
-    {
-        std::unique_lock<decltype(mutex)> lock(mutex);
-
-        cv.wait(lock, [&]{ return done; });
-    }
-
-    done = false;
-
-    if (buffer)
-        buffer_stream.release_client_buffer(buffer);
-    buffer_stream.acquire_client_buffer(callback);
-
-    {
-        std::unique_lock<decltype(mutex)> lock(mutex);
-
-        cv.wait(lock, [&]{ return done; });
-    }
-}
-
-TEST_F(BufferStreamTest, allow_framedropping_device)
-{
-    EXPECT_CALL(*mock_bundle, allow_framedropping(true))
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    buffer_stream.allow_framedropping(true);
-}
-
-TEST_F(BufferStreamTest, resizes_bundle)
-{
-    geom::Size const new_size{66, 77};
-
-    EXPECT_CALL(*mock_bundle, resize(new_size))
-        .Times(1);
-
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
-    buffer_stream.resize(new_size);
-}
-
 
=== modified file 'tests/unit-tests/compositor/test_gl_renderer.cpp'
--- tests/unit-tests/compositor/test_gl_renderer.cpp	2015-01-22 09:00:14 +0000
+++ tests/unit-tests/compositor/test_gl_renderer.cpp	2015-03-20 19:31:52 +0000
@@ -28,8 +28,7 @@
 #include <mir_test/fake_shared.h>
 #include <mir_test_doubles/mock_buffer.h>
 #include <mir_test_doubles/mock_renderable.h>
-#include <mir_test_doubles/mock_buffer_stream.h>
-#include <mir/compositor/buffer_stream.h>
+#include <mir_test_doubles/mock_buffer_bundle.h>
 #include <mir_test_doubles/mock_gl.h>
 
 using testing::SetArgPointee;
 
=== removed file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	1970-01-01 00:00:00 +0000
@@ -1,149 +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 "src/server/compositor/temporary_buffers.h"
-#include "mir_test_doubles/mock_buffer.h"
-#include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/mock_buffer_bundle.h"
-#include <gtest/gtest.h>
-#include <stdexcept>
-
-namespace mtd=mir::test::doubles;
-namespace mg = mir::graphics;
-namespace mc=mir::compositor;
-namespace geom=mir::geometry;
-
-namespace
-{
-class TemporaryTestBuffer : public mc::TemporaryBuffer
-{
-public:
-    TemporaryTestBuffer(const std::shared_ptr<mg::Buffer>& buf)
-        : TemporaryBuffer(buf)
-    {
-    }
-};
-
-class TemporaryBuffersTest : public ::testing::Test
-{
-public:
-    TemporaryBuffersTest()
-        : buffer_size{1024, 768},
-          buffer_stride{1024},
-          buffer_pixel_format{mir_pixel_format_abgr_8888},
-          mock_buffer{std::make_shared<testing::NiceMock<mtd::MockBuffer>>(
-                          buffer_size, buffer_stride, buffer_pixel_format)},
-          mock_bundle{std::make_shared<testing::NiceMock<mtd::MockBufferBundle>>()}
-    {
-        using namespace testing;
-
-        ON_CALL(*mock_bundle, client_acquire(_))
-            .WillByDefault(InvokeArgument<0>(mock_buffer.get()));
-        ON_CALL(*mock_bundle, compositor_acquire(_))
-            .WillByDefault(Return(mock_buffer));
-    }
-
-    geom::Size const buffer_size;
-    geom::Stride const buffer_stride;
-    MirPixelFormat const buffer_pixel_format;
-    std::shared_ptr<mtd::MockBuffer> const mock_buffer;
-    std::shared_ptr<mtd::MockBufferBundle> mock_bundle;
-};
-}
-
-TEST_F(TemporaryBuffersTest, compositor_buffer_acquires_and_releases)
-{
-    using namespace testing;
-    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_bundle, compositor_release(_))
-        .Times(1);
-
-    mc::TemporaryCompositorBuffer proxy_buffer(mock_bundle, 0);
-}
-
-TEST_F(TemporaryBuffersTest, snapshot_buffer_acquires_and_releases)
-{
-    using namespace testing;
-    EXPECT_CALL(*mock_bundle, snapshot_acquire())
-        .WillOnce(Return(mock_buffer));
-    EXPECT_CALL(*mock_bundle, snapshot_release(_))
-        .Times(1);
-
-    mc::TemporarySnapshotBuffer proxy_buffer(mock_bundle);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_size)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, size())
-        .Times(1);
-
-    geom::Size size;
-    size = proxy_buffer.size();
-    EXPECT_EQ(buffer_size, size);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_stride)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, stride())
-        .Times(1);
-
-    geom::Stride stride;
-    stride = proxy_buffer.stride();
-    EXPECT_EQ(buffer_stride, stride);
-}
-
-TEST_F(TemporaryBuffersTest, base_test_pixel_format)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, pixel_format())
-        .Times(1);
-
-    MirPixelFormat pixel_format;
-    pixel_format = proxy_buffer.pixel_format();
-    EXPECT_EQ(buffer_pixel_format, pixel_format);
-}
-
-TEST_F(TemporaryBuffersTest, base_gl_bind_to_texture)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, gl_bind_to_texture())
-        .Times(1);
-
-    proxy_buffer.gl_bind_to_texture();
-}
-
-TEST_F(TemporaryBuffersTest, base_test_id)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, id())
-        .Times(1);
-
-    proxy_buffer.id();
-}
-
-TEST_F(TemporaryBuffersTest, base_test_native_buffer_handle)
-{
-    TemporaryTestBuffer proxy_buffer(mock_buffer);
-    EXPECT_CALL(*mock_buffer, native_buffer_handle())
-        .Times(1);
-
-    proxy_buffer.native_buffer_handle();
-}
 
=== modified file 'tests/unit-tests/examples/test_demo_compositor.cpp'
--- tests/unit-tests/examples/test_demo_compositor.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/examples/test_demo_compositor.cpp	2015-03-20 19:31:52 +0000
@@ -27,7 +27,7 @@
 
 #include "mir_test_doubles/mock_gl.h"
 #include "mir_test_doubles/stub_display_buffer.h"
-#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_buffer_bundle.h"
 #include "mir_test_doubles/stub_renderable.h"
 #include "mir_test/fake_shared.h"
 
@@ -61,7 +61,7 @@
         std::string("stub"),
         geom::Rectangle{{0,0},{100,100}},
         false,
-        std::make_shared<mtd::StubBufferStream>(),
+        std::make_shared<mtd::StubBufferBundle>(),
         std::shared_ptr<mir::input::InputChannel>(),
         std::shared_ptr<mir::input::InputSender>(),
         std::shared_ptr<mir::graphics::CursorImage>(),
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2015-03-20 19:31:52 +0000
@@ -16,7 +16,6 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "mir/compositor/buffer_stream.h"
 #include "src/server/frontend/session_mediator.h"
 #include "src/server/report/null_report_factory.h"
 #include "src/server/frontend/resource_cache.h"
 
=== modified file 'tests/unit-tests/graphics/test_program_factory.cpp'
--- tests/unit-tests/graphics/test_program_factory.cpp	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/graphics/test_program_factory.cpp	2015-03-20 19:31:52 +0000
@@ -29,8 +29,7 @@
 #include <mir_test/fake_shared.h>
 #include <mir_test_doubles/mock_buffer.h>
 #include <mir_test_doubles/mock_renderable.h>
-#include <mir_test_doubles/mock_buffer_stream.h>
-#include <mir/compositor/buffer_stream.h>
+#include <mir_test_doubles/mock_buffer_bundle.h>
 #include <mir_test_doubles/mock_gl.h>
 
 using testing::SetArgPointee;
 
=== modified file 'tests/unit-tests/scene/test_basic_surface.cpp'
--- tests/unit-tests/scene/test_basic_surface.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/scene/test_basic_surface.cpp	2015-03-20 19:31:52 +0000
@@ -27,7 +27,7 @@
 #include "mir/scene/null_surface_observer.h"
 #include "mir/events/event_builders.h"
 
-#include "mir_test_doubles/mock_buffer_stream.h"
+#include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test_doubles/mock_input_sender.h"
 #include "mir_test_doubles/stub_input_sender.h"
 #include "mir_test_doubles/stub_buffer.h"
@@ -92,8 +92,8 @@
     testing::NiceMock<MockCallback> mock_callback;
     std::function<void()> null_change_cb{[]{}};
     std::function<void()> mock_change_cb{std::bind(&MockCallback::call, &mock_callback)};
-    std::shared_ptr<testing::NiceMock<mtd::MockBufferStream>> mock_buffer_stream =
-        std::make_shared<testing::NiceMock<mtd::MockBufferStream>>();
+    std::shared_ptr<testing::NiceMock<mtd::MockBufferBundle>> mock_buffer_bundle =
+        std::make_shared<testing::NiceMock<mtd::MockBufferBundle>>();
     std::shared_ptr<ms::SceneReport> const report = mr::null_scene_report();
     void const* compositor_id{nullptr};
     std::shared_ptr<ms::LegacySurfaceChangeNotification> observer =
@@ -105,7 +105,7 @@
         name,
         rect,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -135,7 +135,7 @@
     for (int i = 0; i < N; ++i)
     {
         surfaces[i].reset(new ms::BasicSurface(
-                name, rect, false, mock_buffer_stream,
+                name, rect, false, mock_buffer_bundle,
                 std::shared_ptr<mi::InputChannel>(), stub_input_sender,
                 std::shared_ptr<mg::CursorImage>(), report)
             );
@@ -155,7 +155,7 @@
     for (int i = 0; i < N; ++i)
     {
         surfaces[i].reset(new ms::BasicSurface(
-                name, rect, false, mock_buffer_stream,
+                name, rect, false, mock_buffer_bundle,
                 std::shared_ptr<mi::InputChannel>(), stub_input_sender,
                 std::shared_ptr<mg::CursorImage>(), report)
             );
@@ -260,7 +260,7 @@
 {
     using namespace testing;
     mtd::StubBuffer mock_buffer;
-    EXPECT_CALL(*mock_buffer_stream, acquire_client_buffer(_)).Times(2)
+    EXPECT_CALL(*mock_buffer_bundle, client_acquire(_)).Times(2)
         .WillRepeatedly(InvokeArgument<0>(&mock_buffer));
 
     mir::graphics::Buffer* buffer = nullptr;
@@ -271,7 +271,7 @@
         name,
         rect,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -314,7 +314,7 @@
 {
     using namespace testing;
     mtd::StubBuffer mock_buffer;
-    EXPECT_CALL(*mock_buffer_stream, acquire_client_buffer(_)).Times(2)
+    EXPECT_CALL(*mock_buffer_bundle, client_acquire(_)).Times(2)
         .WillRepeatedly(InvokeArgument<0>(&mock_buffer));
 
     surface.add_observer(observer);
@@ -338,7 +338,7 @@
         name,
         geom::Rectangle{pt, one_by_one},
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -376,7 +376,7 @@
         name,
         geom::Rectangle{{0,0}, {100,100}},
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -517,7 +517,7 @@
         geom::Rectangle{{0,0}, {100,100}},
         parent,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -678,7 +678,7 @@
         name,
         rect,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         mt::fake_shared(mock_sender),
         nullptr,
 
=== modified file 'tests/unit-tests/scene/test_session_manager.cpp'
--- tests/unit-tests/scene/test_session_manager.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/scene/test_session_manager.cpp	2015-03-20 19:31:52 +0000
@@ -29,7 +29,7 @@
 
 #include "mir_test_doubles/mock_surface_coordinator.h"
 #include "mir_test_doubles/mock_session_listener.h"
-#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_buffer_bundle.h"
 #include "mir_test_doubles/null_snapshot_strategy.h"
 #include "mir_test_doubles/null_session_event_sink.h"
 
@@ -78,7 +78,7 @@
         std::string("stub"),
         geom::Rectangle{{},{}},
         false,
-        std::make_shared<mtd::StubBufferStream>(),
+        std::make_shared<mtd::StubBufferBundle>(),
         std::shared_ptr<mi::InputChannel>(),
         std::shared_ptr<mi::InputSender>(),
         std::shared_ptr<mg::CursorImage>(),
 
=== modified file 'tests/unit-tests/scene/test_surface.cpp'
--- tests/unit-tests/scene/test_surface.cpp	2015-03-18 18:48:02 +0000
+++ tests/unit-tests/scene/test_surface.cpp	2015-03-20 19:31:52 +0000
@@ -27,7 +27,7 @@
 #include "mir/scene/surface_event_source.h"
 #include "mir/input/input_channel.h"
 
-#include "mir_test_doubles/mock_buffer_stream.h"
+#include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test_doubles/mock_input_surface.h"
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/mock_input_sender.h"
@@ -192,7 +192,7 @@
 {
     SurfaceCreation()
         : surface(surface_name,
-            rect, false, mock_buffer_stream, 
+            rect, false, mock_buffer_bundle,
             std::make_shared<mtd::StubInputChannel>(),
             std::make_shared<mtd::StubInputSender>(),
             nullptr /* cursor_image */, report)
@@ -209,11 +209,11 @@
             notification_count++;
         };
 
-        ON_CALL(*mock_buffer_stream, acquire_client_buffer(_))
+        ON_CALL(*mock_buffer_bundle, client_acquire(_))
             .WillByDefault(InvokeArgument<0>(&stub_buffer));
     }
 
-    std::shared_ptr<testing::NiceMock<mtd::MockBufferStream>> mock_buffer_stream = std::make_shared<testing::NiceMock<mtd::MockBufferStream>>();
+    std::shared_ptr<testing::NiceMock<mtd::MockBufferBundle>> mock_buffer_bundle = std::make_shared<testing::NiceMock<mtd::MockBufferBundle>>();
     std::function<void()> change_notification;
     int notification_count = 0;
     mtd::StubBuffer stub_buffer;
@@ -229,13 +229,15 @@
 
 }
 
-TEST_F(SurfaceCreation, test_surface_queries_stream_for_pf)
+TEST_F(SurfaceCreation, test_surface_queries_bundle_for_pf)
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_buffer_stream, get_stream_pixel_format())
+    EXPECT_CALL(*mock_buffer_bundle, properties())
         .Times(1)
-        .WillOnce(Return(pf));
+        .WillOnce(Return(mg::BufferProperties(geom::Size{0, 0},
+                                              pf,
+                                              mg::BufferUsage::undefined)));
 
     auto ret_pf = surface.pixel_format();
 
@@ -258,7 +260,7 @@
 
     mtd::StubBuffer graphics_resource;
 
-    EXPECT_CALL(*mock_buffer_stream, acquire_client_buffer(_))
+    EXPECT_CALL(*mock_buffer_bundle, client_acquire(_))
         .Times(1)
         .WillOnce(InvokeArgument<0>(&graphics_resource));
 
@@ -267,13 +269,13 @@
         [&graphics_resource](mg::Buffer* result){ EXPECT_THAT(result, Eq(&graphics_resource)); });
 }
 
-TEST_F(SurfaceCreation, test_surface_gets_ipc_from_stream)
+TEST_F(SurfaceCreation, test_surface_gets_ipc_from_bundle)
 {
     using namespace testing;
 
     mtd::StubBuffer stub_buffer;
 
-    EXPECT_CALL(*mock_buffer_stream, acquire_client_buffer(_))
+    EXPECT_CALL(*mock_buffer_bundle, client_acquire(_))
         .Times(1)
         .WillOnce(InvokeArgument<0>(&stub_buffer));
 
@@ -296,12 +298,12 @@
     EXPECT_EQ(p, surface.top_left());
 }
 
-TEST_F(SurfaceCreation, resize_updates_stream_and_state)
+TEST_F(SurfaceCreation, resize_updates_bundle_and_state)
 {
     using namespace testing;
     geom::Size const new_size{123, 456};
 
-    EXPECT_CALL(*mock_buffer_stream, resize(new_size))
+    EXPECT_CALL(*mock_buffer_bundle, resize(new_size))
         .Times(1);
 
     auto const mock_event_sink = std::make_shared<MockEventSink>();
@@ -327,15 +329,15 @@
 
     ASSERT_THAT(surface.size(), Ne(new_size));
 
-    EXPECT_CALL(*mock_buffer_stream, resize(new_size)).Times(1);
+    EXPECT_CALL(*mock_buffer_bundle, resize(new_size)).Times(1);
     EXPECT_CALL(*mock_event_sink, handle_event(_)).Times(1);
     surface.resize(new_size);
     EXPECT_THAT(surface.size(), Eq(new_size));
 
-    Mock::VerifyAndClearExpectations(mock_buffer_stream.get());
+    Mock::VerifyAndClearExpectations(mock_buffer_bundle.get());
     Mock::VerifyAndClearExpectations(mock_event_sink.get());
 
-    EXPECT_CALL(*mock_buffer_stream, resize(_)).Times(0);
+    EXPECT_CALL(*mock_buffer_bundle, resize(_)).Times(0);
     EXPECT_CALL(*mock_event_sink, handle_event(_)).Times(0);
     surface.resize(new_size);
     EXPECT_THAT(surface.size(), Eq(new_size));
@@ -346,7 +348,7 @@
     using namespace testing;
     geom::Size const new_size{123, 456};
 
-    EXPECT_CALL(*mock_buffer_stream, resize(new_size))
+    EXPECT_CALL(*mock_buffer_bundle, resize(new_size))
         .Times(1)
         .WillOnce(Throw(std::runtime_error("bad resize")));
 
@@ -378,7 +380,7 @@
         if (expect_size.height <= geom::Height{0})
             expect_size.height = geom::Height{1};
 
-        EXPECT_CALL(*mock_buffer_stream, resize(expect_size)).Times(1);
+        EXPECT_CALL(*mock_buffer_bundle, resize(expect_size)).Times(1);
         EXPECT_NO_THROW({ surface.resize(size); });
         EXPECT_EQ(expect_size, surface.size());
     }
@@ -407,7 +409,7 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_buffer_stream, force_requests_to_complete()).Times(Exactly(1));
+    EXPECT_CALL(*mock_buffer_bundle, force_requests_to_complete()).Times(Exactly(1));
 
     surface.force_requests_to_complete();
 }
@@ -416,7 +418,7 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_buffer_stream, allow_framedropping(true))
+    EXPECT_CALL(*mock_buffer_bundle, allow_framedropping(true))
         .Times(1);
 
     surface.allow_framedropping(true);
@@ -452,7 +454,7 @@
         surface_name,
         rect,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         mt::fake_shared(channel),
         std::make_shared<mtd::StubInputSender>(),
         std::shared_ptr<mg::CursorImage>(),
@@ -470,7 +472,7 @@
         surface_name,
         rect,
         false,
-        mock_buffer_stream,
+        mock_buffer_bundle,
         std::make_shared<mtd::StubInputChannel>(),
         mt::fake_shared(mock_sender),
         std::shared_ptr<mg::CursorImage>(),
 
=== modified file 'tests/unit-tests/scene/test_surface_impl.cpp'
--- tests/unit-tests/scene/test_surface_impl.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/scene/test_surface_impl.cpp	2015-03-20 19:31:52 +0000
@@ -25,8 +25,8 @@
 #include "mir/frontend/event_sink.h"
 #include "mir/graphics/display_configuration.h"
 
-#include "mir_test_doubles/stub_buffer_stream.h"
-#include "mir_test_doubles/mock_buffer_stream.h"
+#include "mir_test_doubles/stub_buffer_bundle.h"
+#include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test_doubles/mock_input_targeter.h"
 #include "mir_test_doubles/stub_input_sender.h"
 #include "mir_test_doubles/null_event_sink.h"
@@ -53,23 +53,22 @@
 namespace
 {
 
-typedef testing::NiceMock<mtd::MockBufferStream> StubBufferStream;
+typedef testing::NiceMock<mtd::MockBufferBundle> StubBufferBundle;
 
 struct Surface : testing::Test
 {
-    std::shared_ptr<StubBufferStream> const buffer_stream = std::make_shared<StubBufferStream>();
+    std::shared_ptr<StubBufferBundle> const buffer_bundle = std::make_shared<StubBufferBundle>();
 
     void SetUp()
     {
         using namespace testing;
 
-        ON_CALL(*buffer_stream, stream_size()).WillByDefault(Return(geom::Size()));
-        ON_CALL(*buffer_stream, get_stream_pixel_format()).WillByDefault(Return(mir_pixel_format_abgr_8888));
-        ON_CALL(*buffer_stream, acquire_client_buffer(_))
+        ON_CALL(*buffer_bundle, size()).WillByDefault(Return(geom::Size()));
+        ON_CALL(*buffer_bundle, client_acquire(_))
             .WillByDefault(InvokeArgument<0>(nullptr));
         
         surface = std::make_shared<ms::BasicSurface>(std::string("stub"), geom::Rectangle{{},{}}, false,
-            buffer_stream, nullptr /* input_channel */, stub_input_sender,
+            buffer_bundle, nullptr /* input_channel */, stub_input_sender,
             nullptr /* cursor_image */, report);
     }
 
@@ -264,13 +263,13 @@
 
 TEST_F(Surface, with_most_recent_buffer_do_uses_compositor_buffer)
 {
-    auto stub_buffer_stream = std::make_shared<mtd::StubBufferStream>();
+    auto stub_buffer_bundle = std::make_shared<mtd::StubBufferBundle>();
 
     ms::BasicSurface surf(
         std::string("stub"),
         geom::Rectangle{{},{}},
         false,
-        stub_buffer_stream,
+        stub_buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
@@ -284,7 +283,7 @@
             buf_ptr = &buffer;
         });
 
-    EXPECT_EQ(stub_buffer_stream->stub_compositor_buffer.get(), buf_ptr);
+    EXPECT_EQ(stub_buffer_bundle->stub_compositor_buffer.get(), buf_ptr);
 }
 
 TEST_F(Surface, emits_client_close_events)
@@ -314,7 +313,7 @@
         std::string("stub"),
         geom::Rectangle{{},{}},
         false,
-        buffer_stream,
+        buffer_bundle,
         std::shared_ptr<mi::InputChannel>(),
         stub_input_sender,
         std::shared_ptr<mg::CursorImage>(),
 
=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2015-03-06 03:52:41 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2015-03-20 19:31:52 +0000
@@ -27,9 +27,9 @@
 #include "mir/input/input_channel_factory.h"
 #include "mir_test_doubles/stub_input_channel.h"
 #include "mir_test/fake_shared.h"
-#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_buffer_bundle.h"
 #include "mir_test_doubles/stub_renderable.h"
-#include "mir_test_doubles/mock_buffer_stream.h"
+#include "mir_test_doubles/mock_buffer_bundle.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -125,7 +125,7 @@
             std::string("stub"),
             geom::Rectangle{{},{}},
             false,
-            std::make_shared<mtd::StubBufferStream>(),
+            std::make_shared<mtd::StubBufferBundle>(),
             std::shared_ptr<mir::input::InputChannel>(),
             std::shared_ptr<mir::input::InputSender>(),
             std::shared_ptr<mg::CursorImage>(),
@@ -137,7 +137,7 @@
             std::string("stub"),
             geom::Rectangle{{},{}},
             false,
-            std::make_shared<mtd::StubBufferStream>(),
+            std::make_shared<mtd::StubBufferBundle>(),
             std::shared_ptr<mir::input::InputChannel>(),
             std::shared_ptr<mir::input::InputSender>(),
             std::shared_ptr<mg::CursorImage>(),
@@ -149,7 +149,7 @@
             std::string("stub"),
             geom::Rectangle{{},{}},
             false,
-            std::make_shared<mtd::StubBufferStream>(),
+            std::make_shared<mtd::StubBufferBundle>(),
             std::shared_ptr<mir::input::InputChannel>(),
             std::shared_ptr<mir::input::InputSender>(),
             std::shared_ptr<mg::CursorImage>(),
@@ -161,7 +161,7 @@
             std::string("stub"),
             geom::Rectangle{{},{}},
             false,
-            std::make_shared<mtd::StubBufferStream>(),
+            std::make_shared<mtd::StubBufferBundle>(),
             std::shared_ptr<mir::input::InputChannel>(),
             std::shared_ptr<mir::input::InputSender>(),
             std::shared_ptr<mg::CursorImage>(),
@@ -236,7 +236,7 @@
         std::string("Mary had a little lamb"),
         geom::Rectangle{{},{}},
         false,
-        std::make_shared<mtd::StubBufferStream>(),
+        std::make_shared<mtd::StubBufferBundle>(),
         std::shared_ptr<mir::input::InputChannel>(),
         std::shared_ptr<mir::input::InputSender>(),
         std::shared_ptr<mg::CursorImage>(),