Merge lp:~vanvugt/mir/switch into lp:~mir-team/mir/trunk

[Daniel van Vugt]

Simplify and generalize buffer swapping to support arbitrary numbers of:
  - buffers
  - compositors
  - clients

This is a unified N-buffers algorithm which supports any positive number of
buffers, as well as dynamically switching between synchronous and
asynchronous behaviour. So it does everything the existing code does and
more.

The key requirement is to support an arbitrary number of (different)
simultaneous compositor acquisitions, as is needed for bypass support
(coming soon). This then leads to the requirement that a compositor and a
snapshot buffer should be acquired differently. Because a snapshot should
never consume frames, only observe them. On the other hand, a compositior
acquire must consume a frame (if available) so as to guarantee correct
ordering when more than one are acquired simultaneously in bypass mode.

Also fixes LP: #1199717 and is half the fix for LP: #1199450.

Advantages over the existing buffer swapping logic:

  - Completely generalized to support N-buffering, with N > 0.
  - Compositor acquisitions are guaranteed to consume frames (if available),
    even with multiple acquired (required for bypass).
  - Snapshots never consume/steal compositor frames. I suspect this could
    happen in the old code, but at least it's now guaranteed not to.
  - Frame ordering is easier to follow and guarantee as buffers are kept in
    a single ring.
  - The code is much smaller, and easier to fully absorb for new developers,
    than the thousands of lines it replaces.
  - Simpler logic provides clearer guarantees, and fewer exceptions are
    possible.
  - Short term: It works with bypass, today. Unblocking that task.
  - Long term: Much easier to maintain a smaller code base (providing there's
    adequate test coverage).
  - Also fixes LP: #1199717 and is half the fix for LP: #1199450.

Disadvantages:

  - Newer code is less mature by definition, so always carries risk.
  - More concentrated code is more sensitive to programming mistakes. Though
    that's only a problem if tests are lacking.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:995
http://jenkins.qa.ubuntu.com/job/mir-ci/1168/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1537
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1422/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/406
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/406/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Not a thorough review yet... some problems I noticed while trying the branch out (I also cherrypicked the changes from multimonitor-examples MP to be able to easily try out multimonitor support):

1. render_surfaces is rendering in a small part of the output (instead of taking up the whole screen)
2. mir_demo_client_accelerated seems a bit choppy vs when running under lp:mir
3. Multimonitor support (non-cloned) is not working. I get a "compositor release out of order" when a surface is displayed on two outputs. It seems that this MP changes/removes some of the mechanism needed for MM support without providing an alternative.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:996
http://jenkins.qa.ubuntu.com/job/mir-ci/1182/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1557
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1442/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/420
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/420/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:997
http://jenkins.qa.ubuntu.com/job/mir-ci/1183/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1558
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1443
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/421
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/421/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Thanks for the quick response Alexandros. All fixed!

Unfortunately I had to drop the original fix/workaround for bug 1199450. It was a too hacky for my liking anyway. An alternative is proposed in lp:~vanvugt/mir/fix-1199450.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1002
http://jenkins.qa.ubuntu.com/job/mir-ci/1190/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1569
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1454
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/428/console
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/428/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Failure looks like intrastructure - restarting

[Alan Griffiths (alan-griffiths)]

63 + GLint old_viewport[4];
...
50 + glViewport(old_viewport[0], old_viewport[1],
51 + old_viewport[2], old_viewport[3]);

Maybe I'm missing something, but why use a GLint array and "magic number" indexes?

Oh, I see - glGetIntegerv(GLenum pname, GLint * params) - that's an inconsistent API.

I guess if this is all it is used for it's OK.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1002
http://jenkins.qa.ubuntu.com/job/mir-ci/1194/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1573
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1458
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/432
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/432/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

This version doesn't crash with multiple monitors anymore. However, there are still some issues with multiple monitors, and in particular when a surface is visible on more than one (non-cloned) outputs. Because of the removal of MultiAcquisitionBackBufferStrategy (which significantly improved, but didn't completely cure the problem), it's much more likely that the compositor for an ouput will miss a frame (because it was consumed by the compositor of another output) and use the next available one. Depending on the relative timings of the vsyncs of the outputs, this causes some stuttering and increased frame rates for applications that continously update, but may lead to serious output inconsistencies for apps that update occasionally.

Note that this is not needed for XMir (and the system compositor in general?), since they deal with fullscreen surfaces only, so it may be OK to postpone solving this for a little while. However, it is an important issue and we should work to find an acceptable solution. As discussed in other occasions, it could be the case that there is no perfect solution and we will just have to find a compromise that minimizes artifacts and keeps frame rates sane.

1961 + BOOST_THROW_EXCEPTION(std::logic_error(
1962 + "compositor_acquire would block; probably too many clients."));

This concerns me. The swapper/bundle should never get into this situation. Previously we guaranteed this by blocking the client if it was about to get a buffer that would lead to the compositor not having any buffers. Can't we do the same in the new mechanism?

review: Needs Information

[Alexandros Frantzis (afrantzis)]

A possible way forward is to keep MultiAcquisitionBackBufferStrategy, until we find a better solution, but only for normal buffer bundles. Bypassing buffer bundles can use a different, trivial back buffer strategy.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1003
http://jenkins.qa.ubuntu.com/job/mir-ci/1199/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1580
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1465
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/437
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/437/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Alexandros,

I did expect some multi-monitor problems, and certainly expected the high-framerate/stutter issue. I believe we already agreed to discuss this problem starting today... I have one workaround in mind that would work, but it's not elegant: Just don't give out new compositor buffers any more frequently than about 10ms. I was hoping our discussions might lead to a more elegant solution though.

Bypass requires that successive compositor acquisitions get different buffers. So MultiAcquisitionBackBufferStrategy won't work there. I suggest either the timing approach in the short term, or we discuss how to change the API to compositor_acquire so that it is more multi-monitor friendly, and the reuse rules more explicit.

P.S. Has sufficient multi-monitor support landed in trunk so that I can test it myself?

As for:
  "compositor_acquire would block; probably too many clients."
It's guaranteed to not happen in the current Mir logic, so not a huge issue. I did think the same about guaranteeing it never happens by limiting nclients to 1 or <nbuffers, but that would make the "generalized" algorithm less generalized. Less elegant.

[Alexandros Frantzis (afrantzis)]

> Bypass requires that successive compositor acquisitions get different buffers. So MultiAcquisitionBackBufferStrategy > won't work there. I suggest either the timing approach in the short term, or we discuss how to change the API to
> compositor_acquire so that it is more multi-monitor friendly, and the reuse rules more explicit.

Since I think we both agree that this is not needed urgently for XMir/system compositor, let's make this MP lighter by leaving it out for now, with the understanding that we will need to look at it in the near future. We can try various solutions and see which gives the best visual result.

> "compositor_acquire would block; probably too many clients."
> It's guaranteed to not happen in the current Mir logic, so not a huge issue. I did think the same about guaranteeing > it never happens by limiting nclients to 1 or <nbuffers, but that would make the "generalized" algorithm less
> generalized. Less elegant.

... but more robust and correct. Since it is a core assumption that the compositor can always get a buffer without delay, I think it is preferable to enforce it, than to fail if the code that uses the swapper doesn't behave as expected. Not a blocker, but worth rethinking/revisiting IMO.

From IRC:

> <duflu> alf__: I just realized the primary thing keeping it at double was removed when I fixed those issues on
> Friday. Now it's only timing keeping it at double. If a client tries to render without using
> a timer (limited only by swapping) then it will expend to triple very quickly now :/

We should fix this... we shouldn't be "wasting" buffers this way if the app doesn't really need them (i.e. it's not framedropping or bypass-ing).

[Alexandros Frantzis (afrantzis)]

There are some issues discussed in previous comments that can be handled in upcoming MPs. The only issue from the ones mentioned that I would prefer if we fixed in this MP (with a test if possible) is:

> If a client tries to render without using a timer (limited only by swapping) then it will expend to triple very quickly now :/

> (first_client + nclients) % nbuffers;
> (i + 1) % nbuffers;
...

I think it would make it easier to understand the algorithms if we express such calculations more descriptively, e.g.:

a = first_free();
b = next_buffer(i);

> 1774 + if (nbuffers < 1)
> 1775 + BOOST_THROW_EXCEPTION(std::logic_error("SwitchingBundle requires a "
> 1776 + "positive number of buffers"));

> 1930 + if (nclients <= 0 || ring[first_client].buf != released_buffer)
> 1931 + BOOST_THROW_EXCEPTION(std::logic_error(
> 1932 + "Client release out of order"));

... and at other places

multi-line statement should be placed in a block

> 2159 + SharedBuffer *ring;

std::vector<SharedBuffer> ring ?

> 4649 +TEST_F(SwitchingBundleTest, out_of_order_compositor_release)

Needs a rename?

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

Alexandros,

Multi-monitor wrong frame rate: FIXED
compositor_acquire would block: TODO (started, but not sure if I agree)
Limit most clients to double-buffering (again): TODO (probably... I need to rethink this)
More descriptive ring functions: FIXED
Multi-line statements in blocks: FIXED
Ring is a vector: I disagree. We don't need any vector template operations.
Rename out_of_order_compositor_release: FIXED

[Alexandros Frantzis (afrantzis)]

> Ring is a vector: I disagree. We don't need any vector template operations.

std::vector provides indexing operations that are as efficient as normal C array indexing operations in proper implementations, and it's safer memory-wise than using new/delete explicitly.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1011
http://jenkins.qa.ubuntu.com/job/mir-ci/1214/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1597
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1482
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/452
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/452/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Hitting EOD, so I'll just drop some notes without voting yet.

~~~~

SwitchingBundle appears to work, but the style seems a bit cryptic. Like Alexandros, I see no advantage to manual memory management. I too prefer std::vector. (Or even an array - is there really any reason why we support nbuffers > 3?).

And then we are using indexes into the "ring" rather than iterators. The issue with this approach is that it mixes switching logic with with "ring iterator" implementation - making both harder to validate individually. (On the other hand it makes for convenient use of the remainder operator - which can aid efficiency.) But like I said, it appears to work.

~~~~

I'd appreciate a brief description of the numerous member variables and the invariant relationships between them. Otherwise it one has to read the code to discover which "int"s perform which roles: e.g. "first_client;" is the index into the ring of the first client whereas "int nclients;" is the current number of buffers /acquired/ by clients. (None of this is hard once familiar with the code, but it eases the learning code.)

~~~~

1866 + auto tmp = ring[slot];
1867 + ring[slot] = ring[i];
1868 + ring[i] = tmp;

    std::swap(ring[slot], ring[i]); // does the same thing, but says what it does.

[Daniel van Vugt (vanvugt)]

Alan,

Memory management: FIXED; converted to a fixed array, max 5 for testing generic N-buffering. Templates I will avoid until they're necessary. I don't want to contribute further to Mir's code bloat with single use template instantiations.

Iterators: I don't think an iterator pattern is appropriate. There is no "begin" or "end", and even an empty sub-queue (nclients==0) should still return a valid position (not end()). Also, I feel a bespoke iterator in this case would hinder understanding of the logic. Because knowing it's a ring is really important. Not something to abstract or hide.

Detailed documentation: Already exists at the top of switching_bundle.cpp

std::swap(): FIXED

=== modified file 'debian/control'
--- debian/control	2013-08-06 22:24:54 +0000
+++ debian/control	2013-08-07 10:49:30 +0000
@@ -69,7 +69,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver0
+Package: libmirserver1
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -99,7 +99,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver0 (= ${binary:Version}),
+Depends: libmirserver1 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

=== renamed file 'debian/libmirserver0.install' => 'debian/libmirserver1.install'
--- debian/libmirserver0.install	2013-08-05 10:56:41 +0000
+++ debian/libmirserver1.install	2013-08-07 10:49:30 +0000
@@ -1,3 +1,3 @@
-usr/lib/*/libmirserver.so.0
+usr/lib/*/libmirserver.so.1
 usr/lib/*/libmirplatform.so
 usr/lib/*/libmirplatformgraphics.so

=== modified file 'examples/buffer_render_target.cpp'
--- examples/buffer_render_target.cpp	2013-07-17 16:38:25 +0000
+++ examples/buffer_render_target.cpp	2013-08-07 10:49:30 +0000
@@ -29,12 +29,20 @@
 mt::BufferRenderTarget::BufferRenderTarget(mg::Buffer& buffer)
     : buffer(buffer)
 {
+    /*
+     * With the new lazy buffer allocation method, we may be executing inside
+     * the compositor's GL context. So be careful to save and restore what
+     * we change...
+     */
+    glGetIntegerv(GL_VIEWPORT, old_viewport);
     resources.setup(buffer);
 }
 
 mt::BufferRenderTarget::~BufferRenderTarget()
 {
     glFinish();
+    glViewport(old_viewport[0], old_viewport[1],
+               old_viewport[2], old_viewport[3]);
 }
 
 void mt::BufferRenderTarget::make_current()

=== modified file 'examples/buffer_render_target.h'
--- examples/buffer_render_target.h	2013-07-17 16:31:45 +0000
+++ examples/buffer_render_target.h	2013-08-07 10:49:30 +0000
@@ -58,6 +58,7 @@
 
     Resources resources;
     mir::graphics::Buffer& buffer;
+    GLint old_viewport[4];
 };
 
 }

=== removed file 'include/server/mir/compositor/back_buffer_strategy.h'
--- include/server/mir/compositor/back_buffer_strategy.h	2013-07-17 16:31:45 +0000
+++ include/server/mir/compositor/back_buffer_strategy.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright © 2013 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]>
- */
-
-#ifndef MIR_COMPOSITOR_BACK_BUFFER_STRATEGY_H_
-#define MIR_COMPOSITOR_BACK_BUFFER_STRATEGY_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace graphics { class Buffer; }
-
-namespace compositor
-{
-class BackBufferStrategy
-{
-public:
-    virtual ~BackBufferStrategy() = default;
-
-    virtual std::shared_ptr<graphics::Buffer> acquire() = 0;
-    virtual void release(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
-
-protected:
-    BackBufferStrategy() = default;
-    BackBufferStrategy(BackBufferStrategy const&) = delete;
-    BackBufferStrategy& operator=(BackBufferStrategy const&) = delete;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BACK_BUFFER_STRATEGY_H_ */

=== removed file 'include/server/mir/compositor/buffer_allocation_strategy.h'
--- include/server/mir/compositor/buffer_allocation_strategy.h	2013-07-31 13:05:21 +0000
+++ include/server/mir/compositor/buffer_allocation_strategy.h	1970-01-01 00:00:00 +0000
@@ -1,63 +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:
- *  Alan Griffiths <[e-mail]>
- *  Thomas Voss <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_BUFFER_ALLOCATION_STRATEGY_H_
-#define MIR_COMPOSITOR_BUFFER_ALLOCATION_STRATEGY_H_
-
-#include "mir/graphics/buffer.h"
-
-#include <vector>
-#include <memory>
-
-namespace mir
-{
-namespace graphics { struct BufferProperties; }
-
-namespace compositor
-{
-class BufferSwapper;
-
-enum class SwapperType
-{
-    synchronous,
-    framedropping,
-    bypass
-};
-
-class BufferAllocationStrategy
-{
-public:
-    virtual std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(graphics::BufferProperties const&,
-        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, SwapperType) const = 0;
-    virtual std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
-        graphics::BufferProperties& actual_properties, graphics::BufferProperties const& requested_properties, SwapperType) const = 0;
-
-protected:
-    BufferAllocationStrategy() {}
-    virtual ~BufferAllocationStrategy() { /* TODO: make nothrow */ }
-
-    BufferAllocationStrategy(const BufferAllocationStrategy&);
-    BufferAllocationStrategy& operator=(const BufferAllocationStrategy& );
-};
-
-}
-}
-
-#endif // MIR_COMPOSITOR_BUFFER_ALLOCATION_STRATEGY_H_

=== modified file 'include/server/mir/compositor/buffer_stream_factory.h'
--- include/server/mir/compositor/buffer_stream_factory.h	2013-07-31 11:00:22 +0000
+++ include/server/mir/compositor/buffer_stream_factory.h	2013-08-07 10:49:30 +0000
@@ -27,27 +27,27 @@
 
 namespace mir
 {
+namespace graphics
+{
+class GraphicBufferAllocator;
+}
 namespace compositor
 {
 
-class BufferAllocationStrategy;
-class GraphicBufferAllocator;
-
 class BufferStreamFactory : public surfaces::BufferStreamFactory
 {
 public:
 
     explicit BufferStreamFactory(
-        const std::shared_ptr<BufferAllocationStrategy>& strategy);
+        const std::shared_ptr<graphics::GraphicBufferAllocator> &gralloc);
 
     virtual ~BufferStreamFactory() {}
 
-    // From BufferStreamFactory
     virtual std::shared_ptr<surfaces::BufferStream> create_buffer_stream(
         graphics::BufferProperties const& buffer_properties);
 
 private:
-    std::shared_ptr<BufferAllocationStrategy> swapper_factory;
+    std::shared_ptr<graphics::GraphicBufferAllocator> gralloc;
 
 };
 

=== modified file 'include/server/mir/compositor/buffer_stream_surfaces.h'
--- include/server/mir/compositor/buffer_stream_surfaces.h	2013-07-31 11:00:22 +0000
+++ include/server/mir/compositor/buffer_stream_surfaces.h	2013-08-07 10:49:30 +0000
@@ -55,7 +55,6 @@
 
 private:
     std::shared_ptr<BufferBundle> const buffer_bundle;
-    std::shared_ptr<BackBufferStrategy> const back_buffer_strategy;
 };
 
 }

=== removed file 'include/server/mir/compositor/buffer_swapper.h'
--- include/server/mir/compositor/buffer_swapper.h	2013-07-17 16:31:45 +0000
+++ include/server/mir/compositor/buffer_swapper.h	1970-01-01 00:00:00 +0000
@@ -1,131 +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_SWAPPER_H_
-#define MIR_COMPOSITOR_BUFFER_SWAPPER_H_
-
-#include <vector>
-#include <memory>
-
-namespace mir
-{
-namespace graphics { class Buffer; }
-
-namespace compositor
-{
-class BufferSwapper
-{
-public:
-    /**
-     * Acquires a free client buffer.
-     *
-     * Callers of client_acquire() are returned a pointer to the currently
-     * usable buffer. Depending on the swapper implementation, this call
-     * may potentially wait for a buffer to become available.
-     *
-     * May throw a mc::BufferSwapperRequestAbortedException.
-     */
-    virtual std::shared_ptr<graphics::Buffer> client_acquire() = 0;
-
-    /**
-     * Releases a client buffer, making it available to the compositor.
-     */
-    virtual void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer) = 0;
-
-    /**
-     * Acquires the last posted buffer.
-     *
-     * Callers of compositor_acquire() should get no-wait access to the
-     * last posted buffer. However, the client will potentially stall
-     * until control of the buffer is returned via a call to
-     * compositor_release().
-     *
-     * Calling compositor_acquire() while a buffer is acquired causes
-     * undefined behavior.
-     *
-     * May throw a mc::BufferSwapperOutOfBuffersException.
-     */
-    virtual std::shared_ptr<graphics::Buffer> compositor_acquire() = 0;
-
-    /**
-     * Releases a compositor buffer, making it available to the client.
-     */
-    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer) = 0;
-
-    /**
-     * Forces client requests on the buffer swapper to abort.
-     *
-     * client_acquire is the only function that can block to provide sync.
-     * This function unblocks client_acquire, generally resulting in an
-     * mc::BufferSwapperRequestAbortedException in threads with a waiting
-     * client_acquire().
-     *
-     * After this request, the compositor can keep acquiring and releasing buffers
-     * but the client cannot. This used in shutdown of the swapper, the client cannot
-     * be reactivated after this call completes.
-     */
-    virtual void force_client_abort() = 0;
-
-    /**
-     * Forces requests on the buffer swapper to complete.
-     *
-     * Requests, like client_acquire(), can block waiting for a buffer to
-     * become available. This method tries to force the request to
-     * complete while ensuring that swapper keeps functioning properly.
-     *
-     * Note that it's not always possible to force a request to complete
-     * without breaking the swapper. It's a logic error to attempt to call
-     * this method if the circumstances don't allow a forced completion.
-     *
-     * To successfully use this method you should ensure that (i.e. the
-     * preconditions for calling this method are):
-     *
-     * - The compositor is not holding any buffers (e.g., it has been stopped).
-     * - The client is trying to acquire at most one buffer at a time (which is
-     *   normal usage, and enforced by the high level API).
-     */
-    virtual void force_requests_to_complete() = 0;
-
-    /**
-     * Ends synchronization of buffers. All buffers owned by the swapper
-     * at the time of this call are transferred to the 'buffers' parameter.
-     * The swapper specifies the number of buffers it was managing (buffers owned by
-     * the swapper plus any outstanding buffers) in 'original_size'. 
-     * After the completion of this call, neither the client, nor the compositor can
-     * continue to request or return buffers to this swapper.
-     */
-    virtual void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>& buffers, size_t& original_size) = 0;
-
-    /**
-     * If the swapper has been used, and you want to preserve the buffers that have been used, 
-     * it is advisable to shutdown the BufferSwapper  by using force_client_abort()
-     * and then end_responsibility(). If these are not called, all buffers within the swapper
-     * will be deallocated
-     */
-    virtual ~BufferSwapper() = default;
-protected:
-    BufferSwapper() = default;
-    BufferSwapper(BufferSwapper const&) = delete;
-    BufferSwapper& operator=(BufferSwapper const&) = delete;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_SWAPPER_H_ */

=== removed file 'include/server/mir/compositor/buffer_swapper_exceptions.h'
--- include/server/mir/compositor/buffer_swapper_exceptions.h	2013-06-15 11:09:16 +0000
+++ include/server/mir/compositor/buffer_swapper_exceptions.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
- * Copyright © 2013 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]>
- */
-
-#ifndef MIR_COMPOSITOR_BUFFER_SWAPPER_EXCEPTIONS_H_
-#define MIR_COMPOSITOR_BUFFER_SWAPPER_EXCEPTIONS_H_
-
-#include <stdexcept>
-
-namespace mir
-{
-namespace compositor
-{
-
-struct BufferSwapperRequestAbortedException : public std::runtime_error
-{
-    BufferSwapperRequestAbortedException() : std::runtime_error("Request aborted") {}
-};
-
-struct BufferSwapperOutOfBuffersException : public std::logic_error
-{
-    BufferSwapperOutOfBuffersException() : std::logic_error("Out of buffers") {}
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_SWAPPER_EXCEPTIONS_H_ */

=== removed file 'include/server/mir/compositor/buffer_swapper_multi.h'
--- include/server/mir/compositor/buffer_swapper_multi.h	2013-07-17 16:31:45 +0000
+++ include/server/mir/compositor/buffer_swapper_multi.h	1970-01-01 00:00:00 +0000
@@ -1,66 +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_SWAPPER_MULTI_H_
-#define MIR_COMPOSITOR_BUFFER_SWAPPER_MULTI_H_
-
-#include "buffer_swapper.h"
-
-#include <mutex>
-#include <condition_variable>
-#include <vector>
-#include <memory>
-#include <deque>
-#include <map>
-
-namespace mir
-{
-namespace compositor
-{
-
-class BufferSwapperMulti : public BufferSwapper
-{
-public:
-    explicit BufferSwapperMulti(std::vector<std::shared_ptr<graphics::Buffer>>& buffer_list, size_t swapper_size);
-
-    std::shared_ptr<graphics::Buffer> client_acquire();
-    void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer);
-    std::shared_ptr<graphics::Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
-
-    void force_client_abort();
-    void force_requests_to_complete();
-    void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&);
-
-private:
-    std::mutex swapper_mutex;
-    std::condition_variable client_available_cv;
-
-    std::deque<std::shared_ptr<graphics::Buffer>> client_queue;
-    std::deque<std::shared_ptr<graphics::Buffer>> compositor_queue;
-    unsigned int in_use_by_client;
-    unsigned int const swapper_size;
-    int clients_trying_to_acquire;
-    bool force_clients_to_abort;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_SWAPPER_MULTI_H_ */

=== removed file 'include/server/mir/compositor/buffer_swapper_spin.h'
--- include/server/mir/compositor/buffer_swapper_spin.h	2013-07-17 16:31:45 +0000
+++ include/server/mir/compositor/buffer_swapper_spin.h	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-/*
- * Copyright © 2013 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]>
- */
-
-#ifndef MIR_COMPOSITOR_BUFFER_SWAPPER_SPIN_H_
-#define MIR_COMPOSITOR_BUFFER_SWAPPER_SPIN_H_
-
-#include "buffer_swapper.h"
-
-#include <mutex>
-#include <vector>
-#include <memory>
-#include <deque>
-
-#include <boost/throw_exception.hpp>
-
-namespace mir
-{
-namespace compositor
-{
-
-class Buffer;
-
-/**
- * Spinning buffer swapping variant
- *
- * BufferSwapperSpin provides a "spinning" swapping variant, in which the
- * client always has an available buffer to draw to, and can submit buffers
- * unrestricted by the vsync rate. When the compositor needs a buffer, it
- * uses the last submitted one, and the client continues to "spin" between
- * the remaining buffers.
- */
-class BufferSwapperSpin : public BufferSwapper
-{
-public:
-    BufferSwapperSpin(std::vector<std::shared_ptr<graphics::Buffer>>& buffer_list, size_t swapper_size);
-
-    std::shared_ptr<graphics::Buffer> client_acquire();
-    void client_release(std::shared_ptr<graphics::Buffer> const& queued_buffer);
-    std::shared_ptr<graphics::Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
-
-    void force_client_abort();
-    void force_requests_to_complete();
-    void end_responsibility(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&);
-
-private:
-    std::mutex swapper_mutex;
-
-    std::deque<std::shared_ptr<graphics::Buffer>> buffer_queue;
-    unsigned int in_use_by_client;
-    bool client_submitted_new_buffer;
-    size_t const swapper_size;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_BUFFER_SWAPPER_MULTI_SPIN_H_ */

=== removed file 'include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h'
--- include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h	2013-07-17 16:31:45 +0000
+++ include/server/mir/compositor/multi_acquisition_back_buffer_strategy.h	1970-01-01 00:00:00 +0000
@@ -1,66 +0,0 @@
-/*
- * Copyright © 2013 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]>
- */
-
-#ifndef MIR_COMPOSITOR_MULTI_ACQUISTION_BACK_BUFFER_STRATEGY_H_
-#define MIR_COMPOSITOR_MULTI_ACQUISTION_BACK_BUFFER_STRATEGY_H_
-
-#include "mir/compositor/back_buffer_strategy.h"
-
-#include <memory>
-#include <vector>
-#include <mutex>
-
-namespace mir
-{
-namespace compositor
-{
-class BufferBundle;
-
-namespace detail
-{
-
-struct AcquiredBufferInfo
-{
-    std::weak_ptr<graphics::Buffer> buffer;
-    bool partly_released;
-    int use_count;
-};
-
-}
-
-class MultiAcquisitionBackBufferStrategy : public BackBufferStrategy
-{
-public:
-    MultiAcquisitionBackBufferStrategy(std::shared_ptr<BufferBundle> const& buffer_bundle);
-
-    std::shared_ptr<graphics::Buffer> acquire();
-    void release(std::shared_ptr<graphics::Buffer> const& buffer);
-
-private:
-    std::vector<detail::AcquiredBufferInfo>::iterator find_info(
-        std::shared_ptr<graphics::Buffer> const& buffer);
-
-    std::shared_ptr<BufferBundle> const buffer_bundle;
-    std::vector<detail::AcquiredBufferInfo> acquired_buffers;
-    std::mutex mutex;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_MULTI_ACQUISTION_BACK_BUFFER_STRATEGY_H_ */

=== removed file 'include/server/mir/compositor/swapper_factory.h'
--- include/server/mir/compositor/swapper_factory.h	2013-07-31 11:00:22 +0000
+++ include/server/mir/compositor/swapper_factory.h	1970-01-01 00:00:00 +0000
@@ -1,55 +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: Thomas Voss <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_SWAPPER_FACTORY_H_
-#define MIR_COMPOSITOR_SWAPPER_FACTORY_H_
-
-#include "mir/compositor/buffer_allocation_strategy.h"
-
-namespace mir
-{
-namespace graphics { class GraphicBufferAllocator; }
-
-namespace compositor
-{
-class SwapperFactory : public BufferAllocationStrategy
-{
-public:
-    explicit SwapperFactory(
-        std::shared_ptr<graphics::GraphicBufferAllocator> const& gr_alloc);
-    SwapperFactory(
-        std::shared_ptr<graphics::GraphicBufferAllocator> const& gr_alloc,
-        int number_of_buffers);
-
-    std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(graphics::BufferProperties const&,
-        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, SwapperType) const;
-    std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
-        graphics::BufferProperties& actual_properties, graphics::BufferProperties const& requested_properties, SwapperType) const;
-
-private:
-    void change_swapper_size(
-        std::vector<std::shared_ptr<graphics::Buffer>>&, size_t const, size_t, graphics::BufferProperties const&) const;
-
-    std::shared_ptr<graphics::GraphicBufferAllocator> const gr_allocator;
-    unsigned int const synchronous_number_of_buffers;
-    unsigned int const spin_number_of_buffers;
-};
-}
-}
-
-#endif // MIR_COMPOSITOR_SWAPPER_FACTORY_H_

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-08-06 10:39:53 +0000
+++ include/server/mir/default_server_configuration.h	2013-08-07 10:49:30 +0000
@@ -137,7 +137,6 @@
      *  @{ */
     virtual std::shared_ptr<compositor::DisplayBufferCompositorFactory> the_display_buffer_compositor_factory();
     virtual std::shared_ptr<compositor::OverlayRenderer>          the_overlay_renderer();
-    virtual std::shared_ptr<compositor::BufferAllocationStrategy> the_buffer_allocation_strategy();
     /** @} */
 
     /** @name compositor configuration - dependencies
@@ -247,7 +246,6 @@
     CachedPtr<frontend::SessionMediatorReport> session_mediator_report;
     CachedPtr<frontend::MessageProcessorReport> message_processor_report;
     CachedPtr<frontend::SessionAuthorizer> session_authorizer;
-    CachedPtr<compositor::BufferAllocationStrategy> buffer_allocation_strategy;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
     CachedPtr<surfaces::SurfaceStack> surface_stack;

=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2013-07-31 11:00:22 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2013-08-07 10:49:30 +0000
@@ -41,6 +41,8 @@
     MOCK_METHOD1(client_release,     void(std::shared_ptr<graphics::Buffer> const&));
     MOCK_METHOD0(compositor_acquire, std::shared_ptr<graphics::Buffer>());
     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(allow_framedropping, void(bool));
     MOCK_CONST_METHOD0(properties, graphics::BufferProperties());
     MOCK_METHOD0(force_client_abort, void());

=== removed file 'include/test/mir_test_doubles/mock_swapper.h'
--- include/test/mir_test_doubles/mock_swapper.h	2013-07-17 16:31:45 +0000
+++ include/test/mir_test_doubles/mock_swapper.h	1970-01-01 00:00:00 +0000
@@ -1,66 +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_SWAPPER_H_
-#define MIR_TEST_DOUBLES_MOCK_SWAPPER_H_
-
-#include "mir/compositor/buffer_swapper.h"
-
-#include <gmock/gmock.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockSwapper : public compositor::BufferSwapper
-{
-public:
-    MockSwapper() {}
-    ~MockSwapper() noexcept {}
-
-    MockSwapper(std::shared_ptr<graphics::Buffer> buffer)
-        : default_buffer(buffer)
-    {
-        using namespace testing;
-
-        ON_CALL(*this, compositor_acquire())
-            .WillByDefault(Return(default_buffer));
-        ON_CALL(*this, client_acquire())
-            .WillByDefault(Return(default_buffer));
-    }
-
-    MOCK_METHOD0(client_acquire,     std::shared_ptr<graphics::Buffer>());
-    MOCK_METHOD1(client_release,     void(std::shared_ptr<graphics::Buffer> const&));
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<graphics::Buffer>());
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
-    MOCK_METHOD0(force_client_abort, void());
-    MOCK_METHOD0(force_requests_to_complete, void());
-
-    MOCK_METHOD2(end_responsibility, void(std::vector<std::shared_ptr<graphics::Buffer>>&, size_t&));
-
-private:
-    std::shared_ptr<graphics::Buffer> default_buffer;
-};
-
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_SWAPPER_H_ */

=== removed file 'include/test/mir_test_doubles/mock_swapper_factory.h'
--- include/test/mir_test_doubles/mock_swapper_factory.h	2013-07-31 11:00:22 +0000
+++ include/test/mir_test_doubles/mock_swapper_factory.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright © 2013 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_SWAPPER_FACTORY_H_
-#define MIR_TEST_DOUBLES_MOCK_SWAPPER_FACTORY_H_
-
-#include "mir/compositor/buffer_allocation_strategy.h"
-
-#include <gmock/gmock.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-class MockSwapperFactory : public compositor::BufferAllocationStrategy
-{
-public:
-    ~MockSwapperFactory() noexcept {}
-
-    MOCK_CONST_METHOD4(create_swapper_reuse_buffers,
-        std::shared_ptr<compositor::BufferSwapper>(graphics::BufferProperties const&,
-            std::vector<std::shared_ptr<graphics::Buffer>>&, size_t, compositor::SwapperType));
-    MOCK_CONST_METHOD3(create_swapper_new_buffers,
-        std::shared_ptr<compositor::BufferSwapper>(
-            graphics::BufferProperties&, graphics::BufferProperties const&, compositor::SwapperType));
-};
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_SWAPPER_FACTORY_H_ */

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2013-08-06 07:20:02 +0000
+++ src/server/CMakeLists.txt	2013-08-07 10:49:30 +0000
@@ -84,7 +84,7 @@
   )
 endif()
 
-set(MIRSERVER_ABI 0)
+set(MIRSERVER_ABI 1)
 
 set_target_properties(
   mirserver

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2013-07-26 05:12:14 +0000
+++ src/server/compositor/CMakeLists.txt	2013-08-07 10:49:30 +0000
@@ -7,16 +7,11 @@
   temporary_buffers.cpp
   buffer_stream_factory.cpp
   buffer_stream_surfaces.cpp
-  buffer_swapper_multi.cpp
-  buffer_swapper_spin.cpp
-  swapper_factory.cpp
   rendering_operator.cpp
   gl_renderer.cpp
   gl_renderer_factory.cpp
   multi_threaded_compositor.cpp
   switching_bundle.cpp
-  rw_lock.cpp
-  multi_acquisition_back_buffer_strategy.cpp
 )
 
 ADD_LIBRARY(

=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2013-07-31 13:05:21 +0000
+++ src/server/compositor/buffer_bundle.h	2013-08-07 10:49:30 +0000
@@ -38,6 +38,8 @@
     virtual void client_release(std::shared_ptr<graphics::Buffer> const&) = 0;
     virtual std::shared_ptr<graphics::Buffer> compositor_acquire() = 0;
     virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
+    virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
+    virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;
 
     virtual graphics::BufferProperties properties() const = 0;
     virtual void allow_framedropping(bool dropping_allowed) = 0;

=== modified file 'src/server/compositor/buffer_stream_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2013-07-31 11:18:25 +0000
+++ src/server/compositor/buffer_stream_factory.cpp	2013-08-07 10:49:30 +0000
@@ -18,7 +18,6 @@
  *   Thomas Voss <[e-mail]>
  */
 
-#include "mir/compositor/buffer_allocation_strategy.h"
 #include "mir/compositor/buffer_stream_factory.h"
 #include "mir/compositor/buffer_stream_surfaces.h"
 #include "mir/graphics/buffer_properties.h"
@@ -36,16 +35,17 @@
 namespace ms = mir::surfaces;
 
 mc::BufferStreamFactory::BufferStreamFactory(
-    const std::shared_ptr<BufferAllocationStrategy>& strategy)
-        : swapper_factory(strategy)
+    const std::shared_ptr<mg::GraphicBufferAllocator> &gralloc)
+        : gralloc(gralloc)
 {
-    assert(strategy);
+    assert(gralloc);
 }
 
 
 std::shared_ptr<ms::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
     mg::BufferProperties const& buffer_properties)
 {
-    auto switching_bundle = std::make_shared<mc::SwitchingBundle>(swapper_factory, buffer_properties);
+    // Note: Framedropping and bypass both require a minimum 3 buffers
+    auto switching_bundle = std::make_shared<mc::SwitchingBundle>(3, gralloc, buffer_properties);
     return std::make_shared<mc::BufferStreamSurfaces>(switching_bundle);
 }

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2013-07-31 11:18:25 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2013-08-07 10:49:30 +0000
@@ -20,7 +20,6 @@
 #include "mir/compositor/buffer_stream_surfaces.h"
 #include "buffer_bundle.h"
 #include "mir/graphics/buffer_properties.h"
-#include "mir/compositor/multi_acquisition_back_buffer_strategy.h"
 
 #include "temporary_buffers.h"
 
@@ -29,25 +28,23 @@
 namespace geom = mir::geometry;
 
 mc::BufferStreamSurfaces::BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& buffer_bundle)
-    : buffer_bundle(buffer_bundle),
-      back_buffer_strategy(
-          std::make_shared<MultiAcquisitionBackBufferStrategy>(buffer_bundle))
+    : buffer_bundle(buffer_bundle)
 {
 }
 
 mc::BufferStreamSurfaces::~BufferStreamSurfaces()
 {
+    force_requests_to_complete();
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer()
 {
-    return std::make_shared<mc::TemporaryCompositorBuffer>(back_buffer_strategy);
+    return std::make_shared<mc::TemporaryCompositorBuffer>(buffer_bundle);
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_snapshot_buffer()
 {
-    // TODO (duflu): Implement differently for bypass
-    return std::make_shared<mc::TemporaryCompositorBuffer>(back_buffer_strategy);
+    return std::make_shared<mc::TemporarySnapshotBuffer>(buffer_bundle);
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::secure_client_buffer()

=== removed file 'src/server/compositor/buffer_swapper_multi.cpp'
--- src/server/compositor/buffer_swapper_multi.cpp	2013-07-17 16:31:45 +0000
+++ src/server/compositor/buffer_swapper_multi.cpp	1970-01-01 00:00:00 +0000
@@ -1,174 +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 "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_swapper_exceptions.h"
-#include <boost/throw_exception.hpp>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-
-mc::BufferSwapperMulti::BufferSwapperMulti(std::vector<std::shared_ptr<mg::Buffer>>& buffer_list, size_t swapper_size)
- : in_use_by_client(0),
-   swapper_size(swapper_size),
-   clients_trying_to_acquire(0),
-   force_clients_to_abort(false)
-{
-    if ((swapper_size != 2) && (swapper_size != 3))
-    {
-        BOOST_THROW_EXCEPTION(std::logic_error("BufferSwapperMulti is only validated for 2 or 3 buffers"));
-    }
-
-    for (auto& buffer : buffer_list)
-    {
-        client_queue.push_back(buffer);
-    }
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferSwapperMulti::client_acquire()
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-
-    clients_trying_to_acquire++;
-
-    /*
-     * Don't allow the client to acquire all the buffers, because then the
-     * compositor won't have a buffer to display.
-     */
-    while ((!force_clients_to_abort) &&
-           (client_queue.empty() || (in_use_by_client == (swapper_size - 1))))
-    {
-        client_available_cv.wait(lk);
-    }
-
-    //we have been forced to shutdown
-    if (force_clients_to_abort)
-    {
-        clients_trying_to_acquire--;
-        BOOST_THROW_EXCEPTION(BufferSwapperRequestAbortedException());
-    }
-
-    auto dequeued_buffer = client_queue.front();
-    client_queue.pop_front();
-    in_use_by_client++;
-
-    clients_trying_to_acquire--;
-
-    return dequeued_buffer;
-}
-
-void mc::BufferSwapperMulti::client_release(std::shared_ptr<mg::Buffer> const& queued_buffer)
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-
-    compositor_queue.push_back(queued_buffer);
-    in_use_by_client--;
-
-    /*
-     * At this point we could signal the client_available_cv.  However, we
-     * won't do so, because the cv will get signaled after the next
-     * compositor_release anyway, and we want to avoid the overhead of
-     * signaling at every client_release just to ensure quicker client
-     * notification in an abnormal situation.
-     */
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferSwapperMulti::compositor_acquire()
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-
-    std::shared_ptr<mg::Buffer> dequeued_buffer;
-
-    if (!compositor_queue.empty())
-    {
-        dequeued_buffer = compositor_queue.front();
-        compositor_queue.pop_front();
-    }
-    else if (!client_queue.empty())
-    {
-        dequeued_buffer = client_queue.back();
-        client_queue.pop_back();
-    }
-    else
-    {
-        BOOST_THROW_EXCEPTION(BufferSwapperOutOfBuffersException());
-    }
-
-    return dequeued_buffer;
-}
-
-void mc::BufferSwapperMulti::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-    client_queue.push_back(released_buffer);
-    client_available_cv.notify_one();
-}
-
-void mc::BufferSwapperMulti::force_client_abort()
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-    force_clients_to_abort = true;
-    client_available_cv.notify_all();
-}
-
-void mc::BufferSwapperMulti::force_requests_to_complete()
-{
-    if (in_use_by_client == swapper_size - 1 && clients_trying_to_acquire > 0)
-    {
-        BOOST_THROW_EXCEPTION(
-            std::logic_error("BufferSwapperMulti is not able to force requests to complete:"
-                             " the client is trying to acquire all buffers"));
-    }
-
-    if (client_queue.empty())
-    {
-        if (compositor_queue.empty())
-        {
-            BOOST_THROW_EXCEPTION(
-                std::logic_error("BufferSwapperMulti is not able to force requests to complete:"
-                                 " all buffers are acquired"));
-        }
-
-        auto dequeued_buffer = compositor_queue.front();
-        compositor_queue.pop_front();
-        client_queue.push_back(dequeued_buffer);
-    }
-
-    client_available_cv.notify_all();
-}
-
-
-void mc::BufferSwapperMulti::end_responsibility(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
-                                                size_t& size)
-{
-    std::unique_lock<std::mutex> lk(swapper_mutex);
-
-    while(!compositor_queue.empty())
-    {
-        buffers.push_back(compositor_queue.back());
-        compositor_queue.pop_back();
-    }
-
-    while(!client_queue.empty())
-    {
-        buffers.push_back(client_queue.back());
-        client_queue.pop_back();
-    }
-
-    size = swapper_size;
-}

=== removed file 'src/server/compositor/buffer_swapper_spin.cpp'
--- src/server/compositor/buffer_swapper_spin.cpp	2013-07-17 16:31:45 +0000
+++ src/server/compositor/buffer_swapper_spin.cpp	1970-01-01 00:00:00 +0000
@@ -1,114 +0,0 @@
-/*
- * Copyright © 2013 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 "mir/compositor/buffer_swapper_spin.h"
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-
-mc::BufferSwapperSpin::BufferSwapperSpin(
-    std::vector<std::shared_ptr<mg::Buffer>>& buffer_list, size_t swapper_size)
-    : buffer_queue{buffer_list.begin(), buffer_list.end()},
-      in_use_by_client{0},
-      swapper_size{swapper_size}
-{
-    if (swapper_size != 3)
-    {
-        BOOST_THROW_EXCEPTION(
-            std::logic_error("BufferSwapperSpin is only validated for 3 buffers"));
-    }
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferSwapperSpin::client_acquire()
-{
-    std::lock_guard<std::mutex> lg{swapper_mutex};
-
-    /*
-     * Don't allow the client to acquire all the buffers, because then the
-     * compositor won't have a buffer to display.
-     */
-    if (in_use_by_client == swapper_size - 1)
-    {
-        BOOST_THROW_EXCEPTION(std::logic_error("Client is trying to acquire all buffers at once"));
-    }
-
-    auto dequeued_buffer = buffer_queue.back();
-    buffer_queue.pop_back();
-    in_use_by_client++;
-
-    return dequeued_buffer;
-}
-
-void mc::BufferSwapperSpin::client_release(std::shared_ptr<mg::Buffer> const& queued_buffer)
-{
-    std::lock_guard<std::mutex> lg{swapper_mutex};
-
-    buffer_queue.push_front(queued_buffer);
-    in_use_by_client--;
-    client_submitted_new_buffer = true;
-}
-
-std::shared_ptr<mg::Buffer> mc::BufferSwapperSpin::compositor_acquire()
-{
-    std::lock_guard<std::mutex> lg{swapper_mutex};
-
-    auto dequeued_buffer = buffer_queue.front();
-    buffer_queue.pop_front();
-    client_submitted_new_buffer = false;
-
-    return dequeued_buffer;
-}
-
-void mc::BufferSwapperSpin::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
-{
-    std::lock_guard<std::mutex> lg{swapper_mutex};
-
-    /*
-     * If the client didn't submit a new buffer while the compositor was
-     * holding a buffer, the compositor's buffer is still the newest one, so
-     * place it at the front of the buffer queue. Otherwise, place it at the
-     * back of the buffer queue.
-     */
-    if (client_submitted_new_buffer)
-        buffer_queue.push_back(released_buffer);
-    else
-        buffer_queue.push_front(released_buffer);
-}
-
-void mc::BufferSwapperSpin::force_client_abort()
-{
-}
-
-void mc::BufferSwapperSpin::force_requests_to_complete()
-{
-}
-
-
-void mc::BufferSwapperSpin::end_responsibility(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
-                                                size_t& size)
-{
-    std::lock_guard<std::mutex> lg{swapper_mutex};
-
-    while(!buffer_queue.empty())
-    {
-        buffers.push_back(buffer_queue.back());
-        buffer_queue.pop_back();
-    }
-
-    size = swapper_size;
-}

=== removed file 'src/server/compositor/multi_acquisition_back_buffer_strategy.cpp'
--- src/server/compositor/multi_acquisition_back_buffer_strategy.cpp	2013-07-17 16:31:45 +0000
+++ src/server/compositor/multi_acquisition_back_buffer_strategy.cpp	1970-01-01 00:00:00 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright © 2013 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 "mir/compositor/multi_acquisition_back_buffer_strategy.h"
-#include "mir/compositor/buffer_swapper_exceptions.h"
-#include "buffer_bundle.h"
-
-#include <algorithm>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-
-mc::MultiAcquisitionBackBufferStrategy::MultiAcquisitionBackBufferStrategy(
-    std::shared_ptr<BufferBundle> const& buffer_bundle)
-    : buffer_bundle{buffer_bundle}
-{
-}
-
-std::shared_ptr<mg::Buffer> mc::MultiAcquisitionBackBufferStrategy::acquire()
-{
-    std::lock_guard<std::mutex> lg{mutex};
-
-    /* Try to find an already acquired buffer, that hasn't been partly released */
-    auto iter = std::find_if(acquired_buffers.begin(), acquired_buffers.end(),
-                    [] (detail::AcquiredBufferInfo const& info)
-                    {
-                        return info.partly_released == false;
-                    });
-
-    std::shared_ptr<mg::Buffer> buffer;
-
-    if (iter != acquired_buffers.end())
-    {
-        buffer = iter->buffer.lock();
-    }
-    else
-    {
-        /*
-         * If we couldn't get a non-partly-released acquired buffer,
-         * try to get a new one. If that fails, try to give back a partly
-         * released acquired buffer.
-         */
-        try
-        {
-            buffer = buffer_bundle->compositor_acquire();
-        }
-        catch (mc::BufferSwapperOutOfBuffersException const& e)
-        {
-            if (!acquired_buffers.empty())
-                buffer = acquired_buffers.back().buffer.lock();
-            else
-                throw;
-        }
-
-        iter = find_info(buffer);
-    }
-
-
-    if (iter != acquired_buffers.end())
-        ++iter->use_count;
-    else
-        acquired_buffers.push_back(detail::AcquiredBufferInfo{buffer, false, 1});
-
-    return buffer;
-}
-
-void mc::MultiAcquisitionBackBufferStrategy::release(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    std::lock_guard<std::mutex> lg{mutex};
-
-    auto iter = find_info(buffer);
-
-    bool should_be_released{true};
-
-    if (iter != acquired_buffers.end())
-    {
-        detail::AcquiredBufferInfo& info = *iter;
-
-        --info.use_count;
-
-        if (info.use_count == 0)
-        {
-            acquired_buffers.erase(iter);
-        }
-        else
-        {
-            info.partly_released = true;
-            should_be_released = false;
-        }
-    }
-
-    if (should_be_released)
-        buffer_bundle->compositor_release(buffer);
-}
-
-std::vector<mc::detail::AcquiredBufferInfo>::iterator
-mc::MultiAcquisitionBackBufferStrategy::find_info(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    return std::find_if(acquired_buffers.begin(), acquired_buffers.end(),
-                        [&buffer] (detail::AcquiredBufferInfo const& info)
-                        {
-                            return info.buffer.lock() == buffer;
-                        });
-}

=== removed file 'src/server/compositor/rw_lock.cpp'
--- src/server/compositor/rw_lock.cpp	2013-06-07 15:23:27 +0000
+++ src/server/compositor/rw_lock.cpp	1970-01-01 00:00:00 +0000
@@ -1,71 +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 "rw_lock.h"
-
-namespace mc=mir::compositor;
-
-mc::RWLockWriterBias::RWLockWriterBias()
-    : readers(0),
-      writers(0),
-      waiting_writers(0)
-{
-}
-
-void mc::RWLockWriterBias::read_lock()
-{
-    std::unique_lock<std::mutex> lk(mut);
-    while ((waiting_writers > 0) || (writers > 0))
-    {
-        reader_cv.wait(lk);
-    }
-    readers++;
-}
-
-void mc::RWLockWriterBias::read_unlock()
-{
-    std::unique_lock<std::mutex> lk(mut);
-    readers--;
-    if (readers == 0)
-    {   
-        writer_cv.notify_all();
-    }
-}
-
-void mc::RWLockWriterBias::write_lock()
-{    
-    std::unique_lock<std::mutex> lk(mut);
-    waiting_writers++;
-    while ((readers > 0) || (writers > 0))
-    {
-        writer_cv.wait(lk);
-    }
-    waiting_writers--;
-    writers++;
-}
-
-void mc::RWLockWriterBias::write_unlock()
-{
-    std::unique_lock<std::mutex> lk(mut);
-    writers--;
-
-    reader_cv.notify_all();
-    if (waiting_writers > 0)
-        writer_cv.notify_all();
-}

=== removed file 'src/server/compositor/rw_lock.h'
--- src/server/compositor/rw_lock.h	2013-06-14 14:41:33 +0000
+++ src/server/compositor/rw_lock.h	1970-01-01 00:00:00 +0000
@@ -1,88 +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_RW_LOCK_H_
-#define MIR_COMPOSITOR_RW_LOCK_H_
-
-#include <mutex>
-#include <condition_variable>
-
-namespace mir
-{
-namespace compositor
-{
-
-class ReadLock
-{
-public:
-    void lock() { read_lock(); }
-    void unlock() { read_unlock(); }
-
-    virtual ~ReadLock() = default;
-protected:
-    ReadLock()
-    {
-    }
-private:
-    virtual void read_lock() = 0;
-    virtual void read_unlock() = 0;
-
-    ReadLock(ReadLock const&) = delete;
-    ReadLock& operator=(ReadLock const&) = delete;
-};
-
-class WriteLock
-{
-public:
-    void lock() { write_lock(); }
-    void unlock() { write_unlock(); }
-
-    virtual ~WriteLock() = default;
-protected:
-    WriteLock()
-    {
-    }
-private:
-    virtual void write_lock() = 0;
-    virtual void write_unlock() = 0;
-
-    WriteLock(WriteLock const&) = delete;
-    WriteLock& operator=(WriteLock const&) = delete;
-};
-
-class RWLockWriterBias : public ReadLock, public WriteLock
-{
-public:
-    RWLockWriterBias();
-private:
-    void write_lock();
-    void write_unlock();
-    void read_lock();
-    void read_unlock();
-    std::mutex mut;
-    std::condition_variable reader_cv, writer_cv;
-    unsigned int readers;
-    unsigned int writers;
-    unsigned int waiting_writers;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_RW_LOCK_H_ */

=== removed file 'src/server/compositor/swapper_factory.cpp'
--- src/server/compositor/swapper_factory.cpp	2013-07-31 11:18:25 +0000
+++ src/server/compositor/swapper_factory.cpp	1970-01-01 00:00:00 +0000
@@ -1,118 +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: Alan Griffiths <[e-mail]>
- */
-
-#include "mir/compositor/swapper_factory.h"
-#include "mir/compositor/buffer_allocation_strategy.h"
-#include "mir/graphics/buffer_properties.h"
-#include "mir/graphics/graphic_buffer_allocator.h"
-#include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_swapper_spin.h"
-#include "mir/graphics/buffer_id.h"
-#include "mir/geometry/dimensions.h"
-#include "switching_bundle.h"
-
-#include <initializer_list>
-#include <vector>
-#include <cassert>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-
-mc::SwapperFactory::SwapperFactory(
-        std::shared_ptr<mg::GraphicBufferAllocator> const& gr_alloc,
-        int number_of_buffers)
-    : gr_allocator(gr_alloc),
-      synchronous_number_of_buffers(number_of_buffers),
-      spin_number_of_buffers(3) //spin algorithm always takes 3 buffers
-{
-}
-
-mc::SwapperFactory::SwapperFactory(
-    std::shared_ptr<mg::GraphicBufferAllocator> const& gr_alloc)
-    : SwapperFactory(gr_alloc, 2)
-{
-}
-
-void mc::SwapperFactory::change_swapper_size(
-    std::vector<std::shared_ptr<mg::Buffer>>& list,
-    size_t const desired_size, size_t current_size, mg::BufferProperties const& buffer_properties) const
-{
-    while (current_size < desired_size)
-    {
-        list.push_back(gr_allocator->alloc_buffer(buffer_properties));
-        current_size++;
-    }
- 
-    while (current_size > desired_size)
-    {
-        if (list.empty())
-        {
-            BOOST_THROW_EXCEPTION(std::logic_error("SwapperFactory could not change algorithm"));
-        }
-        else
-        {
-            list.pop_back();
-            current_size--;
-        }
-    }
-}
-
-std::shared_ptr<mc::BufferSwapper> mc::SwapperFactory::create_swapper_reuse_buffers(
-    mg::BufferProperties const& buffer_properties, std::vector<std::shared_ptr<mg::Buffer>>& list,
-    size_t buffer_num, SwapperType type) const
-{
-    if (type == mc::SwapperType::synchronous)
-    {
-        change_swapper_size(list, synchronous_number_of_buffers, buffer_num, buffer_properties);
-        return std::make_shared<mc::BufferSwapperMulti>(list, synchronous_number_of_buffers); 
-    }
-    else
-    {
-        change_swapper_size(list, spin_number_of_buffers, buffer_num, buffer_properties);
-        return std::make_shared<mc::BufferSwapperSpin>(list, spin_number_of_buffers);
-    }
-}
-
-std::shared_ptr<mc::BufferSwapper> mc::SwapperFactory::create_swapper_new_buffers(
-    mg::BufferProperties& actual_buffer_properties,
-    mg::BufferProperties const& requested_buffer_properties, SwapperType type) const
-{
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    std::shared_ptr<mc::BufferSwapper> new_swapper;
-
-    if (type == mc::SwapperType::synchronous)
-    {
-        for(auto i=0u; i< synchronous_number_of_buffers; i++)
-        {
-            list.push_back(gr_allocator->alloc_buffer(requested_buffer_properties));
-        }
-        new_swapper = std::make_shared<mc::BufferSwapperMulti>(list, synchronous_number_of_buffers);
-    }
-    else
-    {
-        for(auto i=0u; i < spin_number_of_buffers; i++)
-        {
-            list.push_back(gr_allocator->alloc_buffer(requested_buffer_properties));
-        }
-        new_swapper = std::make_shared<mc::BufferSwapperSpin>(list, spin_number_of_buffers);
-    }
-
-    actual_buffer_properties = mg::BufferProperties{
-        list[0]->size(), list[0]->pixel_format(), requested_buffer_properties.usage};
-    return new_swapper;
-}

=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2013-07-31 11:00:22 +0000
+++ src/server/compositor/switching_bundle.cpp	2013-08-07 10:49:30 +0000
@@ -13,91 +13,396 @@
  * 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]>
+ * Authored by: Daniel van Vugt <[e-mail]>
+ *
+ *
+ * The "bundle" of buffers is actually a ring (circular array) from which
+ * buffers are allocated and progress through stages.
+ *
+ * The stages of a buffer are:
+ *   free -> client -> ready -> compositor <-> free
+ *                     ready (dropped)-> free
+ *
+ * Dropping only happens when it's enabled, and only if the ring is
+ * completely full.
+ *
+ * The successive stages are contiguous elements in the ring (starting at
+ * element "first_compositor"):
+ *    first_compositor * ncompositors(zero or more)
+ *    first_ready      * nready(zero or more)
+ *    first_client     * nclients(zero or more)
+ *
+ * Therefore you will find:
+ *    first_compositor + ncompositors == first_ready
+ *    first_ready + nready == first_client
+ * although the ring wraps around, so all addition is modulo (%) nbuffers.
+ *
+ * "free" is an implicit state for any buffer that is not in any of the
+ * above three groups. So the next free buffer is always:
+ *    first_client + nclients
+ * and free buffers extend up to but not including first_compositor.
+ *
+ *  |<--------------------- nbuffers ----------------------->|
+ *             | ncompos |    nready    | nclients|
+ *  +----------+---------+--------------+---------+----------+
+ *  | ... free |    |    |    |    |    |    |    | free ... |
+ *  +----------+---------+--------------+---------+----------+
+ *               ^         ^ first_ready  ^ first_client
+ *               first_compositor
+ *
+ * Finally, there is a floating pointer called "snapshot" which can point to
+ * any buffer other than an active client. If nsnappshotters>0 then "snapshot"
+ * currently points to a buffer that is being snapshotted by one or more
+ * threads.
  */
 
-#include "mir/compositor/buffer_swapper.h"
-#include "mir/compositor/buffer_swapper_exceptions.h"
-#include "mir/compositor/buffer_allocation_strategy.h"
+#include "mir/graphics/graphic_buffer_allocator.h"
 #include "switching_bundle.h"
 
 #include <boost/throw_exception.hpp>
+#include <utility>
 
 namespace mc=mir::compositor;
 namespace mg = mir::graphics;
 
 mc::SwitchingBundle::SwitchingBundle(
-    std::shared_ptr<BufferAllocationStrategy> const& swapper_factory, mg::BufferProperties const& property_request)
-    : swapper_factory(swapper_factory),
-      swapper(swapper_factory->create_swapper_new_buffers(
-                  bundle_properties, property_request, mc::SwapperType::synchronous))
-{
+    int nbuffers,
+    const std::shared_ptr<graphics::GraphicBufferAllocator> &gralloc,
+    const mg::BufferProperties &property_request)
+    : bundle_properties{property_request},
+      gralloc{gralloc},
+      nbuffers{nbuffers},
+      first_compositor{0}, ncompositors{0},
+      first_ready{0}, nready{0},
+      first_client{0}, nclients{0},
+      snapshot{-1}, nsnapshotters{0},
+      overlapping_compositors{false},
+      framedropping{false}, force_drop{0}
+{
+    if (nbuffers < 1 || nbuffers > MAX_NBUFFERS)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error("SwitchingBundle only supports "
+                                               "nbuffers betwee 1 and " +
+                                               std::to_string(MAX_NBUFFERS)));
+    }
+
+    for (int i = 0; i < nbuffers; i++)
+        ring[i].users = 0;
+
+    last_consumed = now() - std::chrono::seconds(1);
+}
+
+int mc::SwitchingBundle::nfree() const
+{
+    return nbuffers - ncompositors - nready - nclients;
+}
+
+int mc::SwitchingBundle::first_free() const
+{
+    return (first_client + nclients) % nbuffers;
+}
+
+int mc::SwitchingBundle::next(int slot) const
+{
+    return (slot + 1) % nbuffers;
+}
+
+int mc::SwitchingBundle::prev(int slot) const
+{
+    return (slot + nbuffers - 1) % nbuffers;
+}
+
+int mc::SwitchingBundle::last_compositor() const
+{
+    return (first_compositor + ncompositors - 1) % nbuffers;
+}
+
+int mc::SwitchingBundle::drop_frames(int max)
+{
+    // Drop up to max of the oldest ready frames, and put them on the free list
+    int dropped = (max > nready) ? nready : max;
+
+    for (int d = 0; d < dropped; d++)
+    {
+        auto tmp = ring[first_ready];
+        nready--;
+        first_client = prev(first_client);
+        int end = first_free();
+        int new_snapshot = snapshot;
+
+        for (int i = first_ready, j = 0; i != end; i = j)
+        {
+            j = next(i);
+            ring[i] = ring[j];
+            if (j == snapshot)
+                new_snapshot = i;
+        }
+
+        if (snapshot == first_ready)
+            new_snapshot = end;
+
+        snapshot = new_snapshot;
+
+        ring[end] = tmp;
+    }
+
+    return dropped;
+}
+
+const std::shared_ptr<mg::Buffer> &mc::SwitchingBundle::alloc_buffer(int slot)
+{
+    /*
+     * Many clients will behave in a way that never requires more than 2 or 3
+     * buffers, even though nbuffers may be higher. So to optimize memory
+     * usage for this common case, try to avoid allocating new buffers if
+     * we don't need to.
+     */
+    if (!ring[slot].buf)
+    {
+        int i = first_free();
+        int n = nfree();
+        while (n && !ring[i].buf)
+        {
+            i = next(i);
+            n--;
+        }
+
+        if (i != slot && ring[i].buf && ring[i].buf.unique())
+        {
+            std::swap(ring[slot], ring[i]);
+        }
+        else
+        {
+            ring[slot].buf = gralloc->alloc_buffer(bundle_properties);
+        }
+    }
+
+    return ring[slot].buf;
 }
 
 std::shared_ptr<mg::Buffer> mc::SwitchingBundle::client_acquire()
 {
-    /* lock is for use of 'swapper' below' */
-    std::unique_lock<mc::ReadLock> lk(rw_lock);
-
-    std::shared_ptr<mg::Buffer> buffer = nullptr;
-    while (!buffer) 
-    {
-        try
-        {
-            buffer = swapper->client_acquire();
-        }
-        catch (BufferSwapperRequestAbortedException const& e)
-        {
-            /* wait for the swapper to change before retrying */
-            cv.wait(lk);
-        }
-    }
-    return buffer;
+    std::unique_lock<std::mutex> lock(guard);
+
+    if ((framedropping || force_drop) && nbuffers > 1)
+    {
+        if (nfree() <= 0)
+        {
+            while (nready == 0)
+                cond.wait(lock);
+
+            drop_frames(1);
+        }
+    }
+    else
+    {
+        /*
+         * Even if there are free buffers available, we might wish to still
+         * wait. This is so we don't touch (hence allocate) a third or higher
+         * buffer until/unless it's absolutely necessary. It becomes necessary
+         * only when framedropping (above) or with overlapping compositors
+         * (like with bypass).
+         * The performance benefit of triple buffering is usually minimal,
+         * but always uses 50% more memory. So try to avoid it when possible.
+         */
+
+        int min_free = 
+#if 0  // FIXME: This memory optimization breaks timing tests
+            (nbuffers > 2 && !overlapping_compositors) ?  nbuffers - 1 : 1;
+#else
+            1;
+#endif
+
+        while (nfree() < min_free)
+            cond.wait(lock);
+    }
+
+    if (force_drop > 0)
+        force_drop--;
+
+    int client = first_free();
+    nclients++;
+
+    auto ret = alloc_buffer(client);
+    if (client == snapshot)
+    {
+        /*
+         * In the rare case where a snapshot is still being taken of what is
+         * the new client buffer, try to move it out the way, or if you can't
+         * then wait for the snapshot to finish.
+         */
+        if (nfree() > 0)
+        {
+            snapshot = next(client);
+            std::swap(ring[snapshot], ring[client]);
+            ret = alloc_buffer(client);
+        }
+        else
+        {
+            while (client == snapshot)
+                cond.wait(lock);
+        }
+    }
+
+    return ret;
 }
 
 void mc::SwitchingBundle::client_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
-    std::unique_lock<mc::ReadLock> lk(rw_lock);
-    return swapper->client_release(released_buffer);
+    std::unique_lock<std::mutex> lock(guard);
+
+    if (nclients <= 0 || ring[first_client].buf != released_buffer)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error(
+            "Client release out of order"));
+    }
+
+    first_client = next(first_client);
+    nclients--;
+    nready++;
+    cond.notify_all();
 }
 
 std::shared_ptr<mg::Buffer> mc::SwitchingBundle::compositor_acquire()
 {
-    std::unique_lock<mc::ReadLock> lk(rw_lock);
-    return swapper->compositor_acquire();
+    std::unique_lock<std::mutex> lock(guard);
+    int compositor;
+
+    auto t = now();
+
+    // Multi-monitor acquires close to each other get the same frame:
+    bool same_frame = (t - last_consumed) < std::chrono::milliseconds(10);
+
+    int avail = nfree();
+    bool can_recycle = ncompositors || avail;
+
+    if (!nready || (same_frame && can_recycle))
+    {
+        if (ncompositors)
+        {
+            compositor = last_compositor();
+        }
+        else if (avail)
+        {
+            first_compositor = prev(first_compositor);
+            compositor = first_compositor;
+            ncompositors++;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(std::logic_error(
+                "compositor_acquire would block; probably too many clients."));
+        }
+    }
+    else
+    {
+        compositor = first_ready;
+        first_ready = next(first_ready);
+        nready--;
+        ncompositors++;
+        last_consumed = t;
+    }
+
+    overlapping_compositors = (ncompositors > 1);
+
+    ring[compositor].users++;
+    return alloc_buffer(compositor);
 }
 
 void mc::SwitchingBundle::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
 {
-    std::unique_lock<mc::ReadLock> lk(rw_lock);
-    return swapper->compositor_release(released_buffer);
+    std::unique_lock<std::mutex> lock(guard);
+    int compositor = -1;
+
+    for (int n = 0, i = first_compositor; n < ncompositors; n++, i = next(i))
+    {
+        if (ring[i].buf == released_buffer)
+        {
+            compositor = i;
+            break;
+        }
+    }
+
+    if (compositor < 0)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error(
+            "compositor_release given a non-compositor buffer"));
+    }
+
+    ring[compositor].users--;
+    if (compositor == first_compositor)
+    {
+        while (!ring[first_compositor].users && ncompositors)
+        {
+            first_compositor = next(first_compositor);
+            ncompositors--;
+        }
+        cond.notify_all();
+    }
+}
+
+std::shared_ptr<mg::Buffer> mc::SwitchingBundle::snapshot_acquire()
+{
+    std::unique_lock<std::mutex> lock(guard);
+
+    /*
+     * Note that "nsnapshotters" is a separate counter to ring[x].users.
+     * This is because snapshotters should be completely passive and should
+     * not affect the compositing logic.
+     */
+
+    if (!nsnapshotters)
+    {
+        /*
+         * Always snapshot the newest complete frame, which is always the
+         * one before the first client. But make sure there is at least one
+         * non-client buffer first...
+         */
+        while (nclients >= nbuffers)
+            cond.wait(lock);
+
+        if (!nsnapshotters)
+            snapshot = prev(first_client);
+    }
+
+    nsnapshotters++;
+    return alloc_buffer(snapshot);
+}
+
+void mc::SwitchingBundle::snapshot_release(std::shared_ptr<mg::Buffer> const& released_buffer)
+{
+    std::unique_lock<std::mutex> lock(guard);
+
+    if (nsnapshotters <= 0 || ring[snapshot].buf != released_buffer)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error(
+            "snapshot_release passed a non-snapshot buffer"));
+    }
+
+    nsnapshotters--;
+
+    if (!nsnapshotters)
+        snapshot = -1;
+
+    cond.notify_all();
 }
 
 void mc::SwitchingBundle::force_requests_to_complete()
 {
-    std::unique_lock<mc::ReadLock> lk(rw_lock);
-    swapper->force_requests_to_complete();
+    std::unique_lock<std::mutex> lock(guard);
+    drop_frames(nready);
+    force_drop = nbuffers + 1;
+    cond.notify_all();
 }
 
 void mc::SwitchingBundle::allow_framedropping(bool allow_dropping)
 {
-    {
-        std::unique_lock<mc::ReadLock> lk(rw_lock);
-        swapper->force_client_abort();
-    }
-
-    std::unique_lock<mc::WriteLock> lk(rw_lock);
-    std::vector<std::shared_ptr<mg::Buffer>> list{};
-    size_t size = 0;
-    swapper->end_responsibility(list, size);
-
-    if (allow_dropping)
-        swapper = swapper_factory->create_swapper_reuse_buffers(bundle_properties, list, size, mc::SwapperType::framedropping);
-    else
-        swapper = swapper_factory->create_swapper_reuse_buffers(bundle_properties, list, size, mc::SwapperType::synchronous);
-
-    cv.notify_all();
+    framedropping = allow_dropping;
+}
+
+bool mc::SwitchingBundle::framedropping_allowed() const
+{
+    return framedropping;
 }
 
 mg::BufferProperties mc::SwitchingBundle::properties() const

=== modified file 'src/server/compositor/switching_bundle.h'
--- src/server/compositor/switching_bundle.h	2013-07-31 11:00:22 +0000
+++ src/server/compositor/switching_bundle.h	2013-08-07 10:49:30 +0000
@@ -21,23 +21,27 @@
 #define MIR_COMPOSITOR_SWITCHING_BUNDLE_H_
 
 #include "buffer_bundle.h"
-#include "rw_lock.h"
 #include <condition_variable>
+#include <mutex>
 #include <memory>
-#include <atomic>
+#include <chrono>
 
 namespace mir
 {
+namespace graphics
+{
+class Buffer;
+class GraphicBufferAllocator;
+}
 namespace compositor
 {
-class Buffer;
-class BufferSwapper;
-class BufferAllocationStrategy;
 
 class SwitchingBundle : public BufferBundle 
 {
 public:
-    SwitchingBundle(std::shared_ptr<BufferAllocationStrategy> const& swapper_factory, graphics::BufferProperties const&);
+    SwitchingBundle(int nbuffers,
+                    const std::shared_ptr<graphics::GraphicBufferAllocator> &,
+                    const graphics::BufferProperties &);
 
     graphics::BufferProperties properties() const;
 
@@ -45,15 +49,55 @@
     void client_release(std::shared_ptr<graphics::Buffer> const&);
     std::shared_ptr<graphics::Buffer> compositor_acquire();
     void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
+    std::shared_ptr<graphics::Buffer> snapshot_acquire();
+    void snapshot_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
     void force_requests_to_complete();
     void allow_framedropping(bool dropping_allowed);
+    bool framedropping_allowed() const;
 
 private:
-    graphics::BufferProperties bundle_properties; //must be before swapper
-    std::shared_ptr<BufferAllocationStrategy> const swapper_factory;
-    std::shared_ptr<BufferSwapper> swapper;
-    RWLockWriterBias rw_lock;
-    std::condition_variable_any cv;
+    graphics::BufferProperties bundle_properties;
+    std::shared_ptr<graphics::GraphicBufferAllocator> gralloc;
+
+    int drop_frames(int max);
+    int nfree() const;
+    int first_free() const;
+    int next(int slot) const;
+    int prev(int slot) const;
+    int last_compositor() const;
+
+    const std::shared_ptr<graphics::Buffer> &alloc_buffer(int slot);
+
+    enum {MAX_NBUFFERS = 5};
+    struct SharedBuffer
+    {
+        std::shared_ptr<graphics::Buffer> buf;
+        int users;  // presently just a count of compositors sharing the buf
+    };
+    SharedBuffer ring[MAX_NBUFFERS];
+
+    const int nbuffers;
+    int first_compositor;
+    int ncompositors;
+    int first_ready;
+    int nready;
+    int first_client;
+    int nclients;
+    int snapshot;
+    int nsnapshotters;
+
+    std::mutex guard;
+    std::condition_variable cond;
+
+    typedef std::chrono::high_resolution_clock::time_point time_point;
+    static time_point now()
+        { return std::chrono::high_resolution_clock::now(); }
+    time_point last_consumed;
+
+    bool overlapping_compositors;
+
+    bool framedropping;
+    int force_drop;
 };
 
 }

=== modified file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2013-07-17 16:31:45 +0000
+++ src/server/compositor/temporary_buffers.cpp	2013-08-07 10:49:30 +0000
@@ -16,8 +16,6 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/compositor/back_buffer_strategy.h"
-
 #include "buffer_bundle.h"
 #include "temporary_buffers.h"
 
@@ -43,16 +41,27 @@
 }
 
 mc::TemporaryCompositorBuffer::TemporaryCompositorBuffer(
-    std::shared_ptr<BackBufferStrategy> const& back_buffer_strategy)
-    : TemporaryBuffer(back_buffer_strategy->acquire()),
-      back_buffer_strategy(back_buffer_strategy)
+    std::shared_ptr<BufferBundle> const& bun)
+    : TemporaryBuffer(bun->compositor_acquire()),
+      bundle(bun)
 {
 }
 
 mc::TemporaryCompositorBuffer::~TemporaryCompositorBuffer()
 {
-    if (auto strategy = back_buffer_strategy.lock())
-        strategy->release(buffer);
+    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

=== modified file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2013-07-17 16:38:25 +0000
+++ src/server/compositor/temporary_buffers.h	2013-08-07 10:49:30 +0000
@@ -61,11 +61,22 @@
 {
 public:
     explicit TemporaryCompositorBuffer(
-        std::shared_ptr<BackBufferStrategy> const& back_buffer_strategy);
+        std::shared_ptr<BufferBundle> const& bun);
     ~TemporaryCompositorBuffer();
 
 private:
-    std::weak_ptr<BackBufferStrategy> const back_buffer_strategy;
+    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;
 };
 
 }

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-08-06 10:39:53 +0000
+++ src/server/default_server_configuration.cpp	2013-08-07 10:49:30 +0000
@@ -22,12 +22,9 @@
 #include "mir/shared_library.h"
 
 #include "mir/options/program_option.h"
-#include "mir/compositor/buffer_allocation_strategy.h"
-#include "mir/compositor/buffer_swapper.h"
 #include "mir/compositor/buffer_stream_factory.h"
 #include "mir/compositor/default_display_buffer_compositor_factory.h"
 #include "mir/compositor/multi_threaded_compositor.h"
-#include "mir/compositor/swapper_factory.h"
 #include "mir/compositor/overlay_renderer.h"
 #include "mir/frontend/protobuf_ipc_factory.h"
 #include "mir/frontend/session_mediator_report.h"
@@ -354,16 +351,6 @@
         });
 }
 
-std::shared_ptr<mc::BufferAllocationStrategy>
-mir::DefaultServerConfiguration::the_buffer_allocation_strategy()
-{
-    return buffer_allocation_strategy(
-        [this]()
-        {
-            return std::make_shared<mc::SwapperFactory>(the_buffer_allocator());
-        });
-}
-
 std::shared_ptr<mc::RendererFactory> mir::DefaultServerConfiguration::the_renderer_factory()
 {
     return renderer_factory(
@@ -699,7 +686,7 @@
     return buffer_stream_factory(
         [this]()
         {
-            return std::make_shared<mc::BufferStreamFactory>(the_buffer_allocation_strategy());
+            return std::make_shared<mc::BufferStreamFactory>(the_buffer_allocator());
         });
 }
 

=== modified file 'tests/integration-tests/compositor/CMakeLists.txt'
--- tests/integration-tests/compositor/CMakeLists.txt	2013-06-17 15:55:04 +0000
+++ tests/integration-tests/compositor/CMakeLists.txt	2013-08-07 10:49:30 +0000
@@ -1,6 +1,5 @@
 list(
   APPEND INTEGRATION_TESTS_SRCS
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_stress_buffer_swapper.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_swapping_swappers.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_synchronizer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_stream.cpp

=== modified file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2013-07-31 11:18:25 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	2013-08-07 10:49:30 +0000
@@ -17,7 +17,6 @@
  */
 
 #include "mir/compositor/buffer_stream_surfaces.h"
-#include "mir/compositor/swapper_factory.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "src/server/compositor/switching_bundle.h"
 
@@ -29,6 +28,7 @@
 
 #include <thread>
 #include <chrono>
+#include <atomic>
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
@@ -43,69 +43,95 @@
 struct BufferStreamTest : public ::testing::Test
 {
     BufferStreamTest()
-        : buffer_stream{create_bundle()}
+        : nbuffers{3},
+          buffer_stream{create_bundle()}
     {
     }
 
     std::shared_ptr<mc::BufferBundle> create_bundle()
     {
         auto allocator = std::make_shared<mtd::StubBufferAllocator>();
-        auto factory = std::make_shared<mc::SwapperFactory>(allocator);
         mg::BufferProperties properties{geom::Size{380, 210},
                                         geom::PixelFormat::abgr_8888,
                                         mg::BufferUsage::hardware};
 
-        return std::make_shared<mc::SwitchingBundle>(factory, properties);
-    }
-
-    void terminate_child_thread(mt::Synchronizer& controller)
-    {
-        controller.ensure_child_is_waiting();
-        controller.kill_thread();
-        controller.activate_waiting_child();
-    }
-
+        return std::make_shared<mc::SwitchingBundle>(nbuffers,
+                                                     allocator,
+                                                     properties);
+    }
+
+    const int nbuffers;
     mc::BufferStreamSurfaces buffer_stream;
-    std::atomic<bool> client_thread_done;
 };
 
-}
-
-TEST_F(BufferStreamTest, gives_same_back_buffer_until_one_is_released)
-{
-    buffer_stream.secure_client_buffer().reset();
-    buffer_stream.secure_client_buffer().reset();
+void sleep_one_frame()
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(16));
+}
+
+}
+
+TEST_F(BufferStreamTest, gives_same_back_buffer_until_more_available)
+{
+    auto client1 = buffer_stream.secure_client_buffer();
+    auto client1_id = client1->id();
+    client1.reset();
 
     auto comp1 = buffer_stream.lock_compositor_buffer();
     auto comp2 = buffer_stream.lock_compositor_buffer();
 
     EXPECT_EQ(comp1->id(), comp2->id());
+    EXPECT_EQ(comp1->id(), client1_id);
 
     comp1.reset();
 
+    buffer_stream.secure_client_buffer().reset();
+    sleep_one_frame();
     auto comp3 = buffer_stream.lock_compositor_buffer();
 
-    EXPECT_NE(comp2->id(), comp3->id());
-}
-
-TEST_F(BufferStreamTest, multiply_acquired_back_buffer_is_returned_to_client)
-{
-    buffer_stream.secure_client_buffer().reset();
-    buffer_stream.secure_client_buffer().reset();
-
-    auto comp1 = buffer_stream.lock_compositor_buffer();
-    auto comp2 = buffer_stream.lock_compositor_buffer();
-
-    EXPECT_EQ(comp1->id(), comp2->id());
-
-    auto comp_id = comp1->id();
-
-    comp1.reset();
+    EXPECT_NE(client1_id, comp3->id());
+
     comp2.reset();
-
-    auto client1 = buffer_stream.secure_client_buffer();
-
-    EXPECT_EQ(comp_id, client1->id());
+    auto comp3_id = comp3->id();
+    comp3.reset();
+
+    auto comp4 = buffer_stream.lock_compositor_buffer();
+    EXPECT_EQ(comp3_id, comp4->id());
+}
+
+TEST_F(BufferStreamTest, gives_all_monitors_the_same_buffer)
+{
+    for (int i = 0; i < nbuffers - 1; i++)
+        buffer_stream.secure_client_buffer().reset();
+
+    auto first_monitor = buffer_stream.lock_compositor_buffer();
+    auto first_compositor_id = first_monitor->id();
+    first_monitor.reset();
+
+    for (int m = 0; m < 10; m++)
+    {
+        auto monitor = buffer_stream.lock_compositor_buffer();
+        ASSERT_EQ(first_compositor_id, monitor->id());
+    }
+}
+
+TEST_F(BufferStreamTest, gives_different_back_buffer_asap)
+{
+    if (nbuffers > 1)
+    {
+        buffer_stream.secure_client_buffer().reset();
+        auto comp1 = buffer_stream.lock_compositor_buffer();
+
+        sleep_one_frame();
+
+        buffer_stream.secure_client_buffer().reset();
+        auto comp2 = buffer_stream.lock_compositor_buffer();
+    
+        EXPECT_NE(comp1->id(), comp2->id());
+    
+        comp1.reset();
+        comp2.reset();
+    }
 }
 
 TEST_F(BufferStreamTest, can_get_partly_released_back_buffer)
@@ -128,32 +154,42 @@
 namespace
 {
 
-void client_request_loop(std::shared_ptr<mg::Buffer>& out_buffer,
-                         mt::SynchronizerSpawned& synchronizer,
-                         ms::BufferStream& stream)
+void client_loop(int nframes, ms::BufferStream& stream)
 {
-    for(;;)
+    for (int f = 0; f < nframes; f++)
     {
-        out_buffer = stream.secure_client_buffer();
+        auto out_buffer = stream.secure_client_buffer();
         ASSERT_NE(nullptr, out_buffer);
-
-        if (synchronizer.child_enter_wait()) return;
-
-        std::this_thread::yield();
-    }
-}
-
-void back_buffer_loop(std::shared_ptr<mg::Buffer>& out_region,
-                      mt::SynchronizerSpawned& synchronizer,
-                      ms::BufferStream& stream)
-{
-    for(;;)
-    {
-        out_region = stream.lock_compositor_buffer();
+        std::this_thread::yield();
+    }
+}
+
+void compositor_loop(ms::BufferStream &stream,
+                     std::atomic<bool> &done)
+{
+    while (!done.load())
+    {
+        auto comp1 = stream.lock_compositor_buffer();
+        ASSERT_NE(nullptr, comp1);
+
+        // Also stress test getting a second compositor buffer before yielding
+        auto comp2 = stream.lock_compositor_buffer();
+        ASSERT_NE(nullptr, comp2);
+
+        std::this_thread::yield();
+
+        comp1.reset();
+        comp2.reset();
+    }
+}
+
+void snapshot_loop(ms::BufferStream &stream,
+                   std::atomic<bool> &done)
+{
+    while (!done.load())
+    {
+        auto out_region = stream.lock_snapshot_buffer();
         ASSERT_NE(nullptr, out_region);
-
-        if (synchronizer.child_enter_wait()) return;
-
         std::this_thread::yield();
     }
 }
@@ -162,72 +198,38 @@
 
 TEST_F(BufferStreamTest, stress_test_distinct_buffers)
 {
-    unsigned int const num_compositors{3};
-    unsigned int const num_iterations{500};
-    std::chrono::microseconds const sleep_duration{50};
-
-    struct CompositorInfo
-    {
-        CompositorInfo(ms::BufferStream& stream)
-            : thread{back_buffer_loop, std::ref(back_buffer),
-                     std::ref(sync), std::ref(stream)}
-        {
-        }
-
-        mt::Synchronizer sync;
-        std::shared_ptr<mg::Buffer> back_buffer;
-        std::thread thread;
-    };
-
-    std::vector<std::unique_ptr<CompositorInfo>> compositors;
-
-    mt::Synchronizer client_sync;
-    std::shared_ptr<mg::Buffer> client_buffer;
-    auto client_thread = std::thread(client_request_loop,  std::ref(client_buffer),
-                                     std::ref(client_sync), std::ref(buffer_stream));
-
-    for (unsigned int i = 0; i < num_compositors; i++)
-    {
-        auto raw = new CompositorInfo{buffer_stream};
-        compositors.push_back(std::unique_ptr<CompositorInfo>(raw));
-    }
-
-    for(unsigned int i = 0; i < num_iterations; i++)
-    {
-        /* Pause the threads */
-        for (auto& info : compositors)
-        {
-            info->sync.ensure_child_is_waiting();
-        }
-        client_sync.ensure_child_is_waiting();
-
-        /*
-         * Check that no compositor has the client's buffer, and release
-         * all the buffers.
-         */
-        for (auto& info : compositors)
-        {
-            EXPECT_NE(info->back_buffer->id(), client_buffer->id());
-            info->back_buffer.reset();
-        }
-        client_buffer.reset();
-
-        /* Restart threads */
-        for (auto& info : compositors)
-        {
-            info->sync.activate_waiting_child();
-        }
-        client_sync.activate_waiting_child();
-
-        std::this_thread::sleep_for(sleep_duration);
-    }
-
-    terminate_child_thread(client_sync);
-    client_thread.join();
-
-    for (auto& info : compositors)
-    {
-        terminate_child_thread(info->sync);
-        info->thread.join();
-    }
+    // 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();
 }

=== removed file 'tests/integration-tests/compositor/test_stress_buffer_swapper.cpp'
--- tests/integration-tests/compositor/test_stress_buffer_swapper.cpp	2013-07-17 16:38:25 +0000
+++ tests/integration-tests/compositor/test_stress_buffer_swapper.cpp	1970-01-01 00:00:00 +0000
@@ -1,308 +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 "mir_test_doubles/stub_buffer.h"
-#include "multithread_harness.h"
-
-#include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/graphics/buffer_id.h"
-
-#include <thread>
-#include <chrono>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace mt = mir::testing;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-
-struct BufferSwapperStress : public ::testing::Test
-{
-public:
-    BufferSwapperStress()
-     : sleep_duration(50),
-       num_iterations(500)
-    {
-        buffer_a = std::make_shared<mtd::StubBuffer>();
-        buffer_b = std::make_shared<mtd::StubBuffer>();
-        buffer_c = std::make_shared<mtd::StubBuffer>();
-    }
-
-    void terminate_child_thread(mt::Synchronizer& controller)
-    {
-        controller.ensure_child_is_waiting();
-        controller.kill_thread();
-        controller.activate_waiting_child();
-    }
-
-    mt::Synchronizer compositor_controller;
-    mt::Synchronizer client_controller;
-
-    std::chrono::microseconds const sleep_duration;
-    int const num_iterations;
-
-    std::thread thread1;
-    std::thread thread2;
-
-    void test_distinct_buffers(mc::BufferSwapper& swapper);
-    void test_valid_buffers(mc::BufferSwapper& swapper);
-    void test_wait_situation(std::vector<std::shared_ptr<mg::Buffer>>& compositor_output_buffers,
-                             std::vector<std::shared_ptr<mg::Buffer>>& client_output_buffers,
-                             mc::BufferSwapper& swapper,
-                             unsigned int number_of_client_requests_to_make);
-    void test_last_posted(mc::BufferSwapper& swapper);
-
-    std::shared_ptr<mg::Buffer> buffer_a;
-    std::shared_ptr<mg::Buffer> buffer_b;
-    std::shared_ptr<mg::Buffer> buffer_c;
-};
-
-void main_test_loop_pause(std::chrono::microseconds duration)
-{
-    std::this_thread::sleep_for(duration);
-}
-
-void client_request_loop(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
-                         mc::BufferSwapper& swapper)
-{
-    for(;;)
-    {
-        out_buffer = swapper.client_acquire();
-        EXPECT_NE(nullptr, out_buffer);
-        if (synchronizer.child_enter_wait()) return;
-
-        swapper.client_release(out_buffer);
-        if (synchronizer.child_enter_wait()) return;
-
-        std::this_thread::yield();
-    }
-}
-
-void compositor_grab_loop(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
-                          mc::BufferSwapper& swapper)
-{
-    for(;;)
-    {
-        out_buffer = swapper.compositor_acquire();
-        EXPECT_NE(nullptr, out_buffer);
-        if (synchronizer.child_enter_wait()) return;
-
-        swapper.compositor_release(out_buffer);
-        if (synchronizer.child_enter_wait()) return;
-        std::this_thread::yield();
-    }
-}
-
-/* test that the compositor and the client are never in ownership of the same
-   buffer */
-void BufferSwapperStress::test_distinct_buffers(mc::BufferSwapper& swapper)
-{
-    std::shared_ptr<mg::Buffer> compositor_buffer;
-    std::shared_ptr<mg::Buffer> client_buffer;
-
-    thread1 = std::thread(compositor_grab_loop, std::ref(compositor_buffer),
-                          std::ref(compositor_controller), std::ref(swapper));
-    thread2 = std::thread(client_request_loop,  std::ref(client_buffer),
-                          std::ref(client_controller), std::ref(swapper));
-
-    for(int i=0; i<  num_iterations; i++)
-    {
-        compositor_controller.ensure_child_is_waiting();
-        client_controller.ensure_child_is_waiting();
-
-        EXPECT_NE(compositor_buffer, client_buffer);
-
-        compositor_controller.activate_waiting_child();
-        client_controller.activate_waiting_child();
-
-        main_test_loop_pause(sleep_duration);
-    }
-
-    terminate_child_thread(client_controller);
-    terminate_child_thread(compositor_controller);
-    thread2.join();
-    thread1.join();
-}
-
-TEST_F(BufferSwapperStress, distinct_and_valid_double_buffers_in_client_and_compositor)
-{
-    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
-    mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
-    test_distinct_buffers(double_swapper);
-}
-TEST_F(BufferSwapperStress, distinct_and_valid_triple_buffers_in_client_and_compositor)
-{
-    auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
-    mc::BufferSwapperMulti triple_swapper(triple_list, triple_list.size());
-    test_distinct_buffers(triple_swapper);
-}
-
-void client_request_loop_finite(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
-                      mt::SynchronizerSpawned& synchronizer,
-                      mc::BufferSwapper& swapper,
-                      int const number_of_requests_to_make)
-{
-    for(auto i=0; i < number_of_requests_to_make; i++)
-    {
-        auto buffer = swapper.client_acquire();
-        swapper.client_release(buffer);
-        buffers.push_back(buffer);
-    }
-
-    synchronizer.child_enter_wait();
-    synchronizer.child_enter_wait();
-}
-
-void compositor_grab(std::vector<std::shared_ptr<mg::Buffer>>& buffers,
-                     mt::SynchronizerSpawned& synchronizer,
-                     mc::BufferSwapper& swapper)
-{
-    synchronizer.child_enter_wait();
-
-    auto buffer = swapper.compositor_acquire();
-    swapper.compositor_release(buffer);
-    buffers.push_back(buffer);
-
-    synchronizer.child_enter_wait();
-}
-
-void BufferSwapperStress::test_wait_situation(std::vector<std::shared_ptr<mg::Buffer>>& compositor_output_buffers,
-                                              std::vector<std::shared_ptr<mg::Buffer>>& client_output_buffers,
-                                              mc::BufferSwapper& swapper,
-                                              unsigned int const number_of_client_requests_to_make)
-{
-    thread1 = std::thread(compositor_grab, std::ref(compositor_output_buffers),
-                          std::ref(compositor_controller), std::ref(swapper));
-    thread2 = std::thread(client_request_loop_finite, std::ref(client_output_buffers),
-                          std::ref(client_controller), std::ref(swapper), number_of_client_requests_to_make);
-
-    compositor_controller.ensure_child_is_waiting();
-
-    client_controller.ensure_child_is_waiting();
-    client_controller.activate_waiting_child();
-
-    compositor_controller.activate_waiting_child();
-    compositor_controller.ensure_child_is_waiting();
-
-    terminate_child_thread(client_controller);
-    terminate_child_thread(compositor_controller);
-    thread2.join();
-    thread1.join();
-
-    ASSERT_EQ(client_output_buffers.size(), number_of_client_requests_to_make);
-    ASSERT_EQ(compositor_output_buffers.size(), static_cast<unsigned int>(1));
-}
-
-TEST_F(BufferSwapperStress, double_test_wait_situation)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
-    std::vector<std::shared_ptr<mg::Buffer>> compositor_buffers;
-    /* a double buffered client should stall on the second request without the compositor running */
-    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
-    mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
-    test_wait_situation(compositor_buffers, client_buffers, double_swapper, 2);
-
-    EXPECT_EQ(client_buffers.at(0), compositor_buffers.at(0));
-}
-
-TEST_F(BufferSwapperStress, triple_test_wait_situation)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
-    std::vector<std::shared_ptr<mg::Buffer>> compositor_buffers;
-    auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
-    mc::BufferSwapperMulti triple_swapper(triple_list, triple_list.size());
-    /* a triple buffered client should stall on the third request without the compositor running */
-    test_wait_situation(compositor_buffers, client_buffers, triple_swapper, 3);
-
-    EXPECT_EQ(client_buffers.at(0), compositor_buffers.at(0));
-}
-
-void client_request_loop_with_wait(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
-                                   mc::BufferSwapper& swapper)
-{
-    bool wait_request = false;
-    for(;;)
-    {
-        wait_request = synchronizer.child_check_wait_request();
-
-        out_buffer = swapper.client_acquire();
-        swapper.client_release(out_buffer);
-
-        if (wait_request)
-            if (synchronizer.child_enter_wait()) return;
-
-        std::this_thread::yield();
-    }
-}
-
-void compositor_grab_loop_with_wait(std::shared_ptr<mg::Buffer>& out_buffer, mt::SynchronizerSpawned& synchronizer,
-                                    mc::BufferSwapper& swapper)
-{
-    std::shared_ptr<mg::Buffer> buffer_ref;
-    bool wait_request = false;
-    for(;;)
-    {
-        wait_request = synchronizer.child_check_wait_request();
-
-        out_buffer = swapper.compositor_acquire();
-        swapper.compositor_release(out_buffer);
-
-        if (wait_request)
-        {
-            out_buffer = swapper.compositor_acquire();
-            if (synchronizer.child_enter_wait()) return;
-            swapper.compositor_release(out_buffer);
-        }
-
-        std::this_thread::yield();
-    }
-}
-
-void BufferSwapperStress::test_last_posted(mc::BufferSwapper& swapper)
-{
-    std::shared_ptr<mg::Buffer> compositor_buffer;
-    std::shared_ptr<mg::Buffer> client_buffer;
-
-    thread1 = std::thread(compositor_grab_loop_with_wait, std::ref(compositor_buffer), std::ref(compositor_controller), std::ref(swapper));
-    thread2 = std::thread(client_request_loop_with_wait,  std::ref(client_buffer), std::ref(client_controller), std::ref(swapper));
-
-    for(int i=0; i<  num_iterations; i++)
-    {
-        client_controller.ensure_child_is_waiting();
-        compositor_controller.ensure_child_is_waiting();
-
-        EXPECT_EQ(compositor_buffer, client_buffer);
-
-        compositor_controller.activate_waiting_child();
-        client_controller.activate_waiting_child();
-
-        main_test_loop_pause(sleep_duration);
-    }
-
-    terminate_child_thread(client_controller);
-    terminate_child_thread(compositor_controller);
-    thread2.join();
-    thread1.join();
-}
-
-TEST_F(BufferSwapperStress, double_test_last_posted)
-{
-    auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
-    mc::BufferSwapperMulti double_swapper(double_list, double_list.size());
-    test_last_posted(double_swapper);
-}

=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-07-31 11:18:25 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-08-07 10:49:30 +0000
@@ -20,10 +20,7 @@
 #include "multithread_harness.h"
 
 #include "src/server/compositor/switching_bundle.h"
-#include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/compositor/buffer_swapper_spin.h"
 #include "mir/compositor/buffer_stream_surfaces.h"
-#include "mir/compositor/swapper_factory.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 
 #include <gmock/gmock.h>
@@ -45,10 +42,10 @@
     void SetUp()
     {
         auto allocator = std::make_shared<mtd::StubBufferAllocator>();
-        auto factory = std::make_shared<mc::SwapperFactory>(allocator, 3);
         auto properties = mg::BufferProperties{geom::Size{380, 210},
-                                          geom::PixelFormat::abgr_8888, mg::BufferUsage::hardware};
-        switching_bundle = std::make_shared<mc::SwitchingBundle>(factory, properties);
+                                          geom::PixelFormat::abgr_8888,
+                                          mg::BufferUsage::hardware};
+        switching_bundle = std::make_shared<mc::SwitchingBundle>(3, allocator, properties);
     }
 
     std::shared_ptr<mc::SwitchingBundle> switching_bundle;

=== modified file 'tests/integration-tests/graphics/android/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/android/test_buffer_integration.cpp	2013-07-31 11:18:25 +0000
+++ tests/integration-tests/graphics/android/test_buffer_integration.cpp	2013-08-07 10:49:30 +0000
@@ -17,10 +17,9 @@
  */
 
 #include "src/server/graphics/android/android_graphic_buffer_allocator.h"
+#include "src/server/compositor/switching_bundle.h"
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/null_display_report.h"
-#include "mir/compositor/swapper_factory.h"
-#include "mir/compositor/buffer_swapper.h"
 #include "mir/graphics/buffer_properties.h"
 
 #include "mir_test/draw/android_graphics.h"
@@ -89,10 +88,10 @@
     using namespace testing;
 
     auto allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(null_buffer_initializer);
-    auto strategy = std::make_shared<mc::SwapperFactory>(allocator);
-    mg::BufferProperties actual;
-    auto swapper = strategy->create_swapper_new_buffers(actual, buffer_properties, mc::SwapperType::synchronous);
-    auto returned_buffer = swapper->client_acquire();
+
+    mc::SwitchingBundle swapper(2, allocator, buffer_properties);
+
+    auto returned_buffer = swapper.client_acquire();
 
     EXPECT_NE(nullptr, returned_buffer);
 }

=== modified file 'tests/integration-tests/graphics/android/test_internal_client.cpp'
--- tests/integration-tests/graphics/android/test_internal_client.cpp	2013-08-02 03:13:38 +0000
+++ tests/integration-tests/graphics/android/test_internal_client.cpp	2013-08-07 10:49:30 +0000
@@ -19,8 +19,6 @@
 #include "src/server/graphics/android/android_graphic_buffer_allocator.h"
 #include "src/server/graphics/android/internal_client_window.h"
 #include "src/server/graphics/android/interpreter_cache.h"
-#include "mir/compositor/swapper_factory.h"
-#include "mir/compositor/buffer_swapper.h"
 #include "mir/compositor/buffer_stream_factory.h"
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/null_display_report.h"
@@ -105,8 +103,7 @@
     auto stub_input_registrar = std::make_shared<mtd::StubInputRegistrar>();
     auto null_buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
     auto allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(null_buffer_initializer);
-    auto strategy = std::make_shared<mc::SwapperFactory>(allocator);
-    auto buffer_stream_factory = std::make_shared<mc::BufferStreamFactory>(strategy);
+    auto buffer_stream_factory = std::make_shared<mc::BufferStreamFactory>(allocator);
     auto surface_allocator = std::make_shared<ms::SurfaceAllocator>(buffer_stream_factory, stub_input_factory);
     auto ss = std::make_shared<ms::SurfaceStack>(surface_allocator, stub_input_registrar);
     auto surface_controller = std::make_shared<ms::SurfaceController>(ss);

=== modified file 'tests/integration-tests/shell/test_session.cpp'
--- tests/integration-tests/shell/test_session.cpp	2013-08-01 08:24:23 +0000
+++ tests/integration-tests/shell/test_session.cpp	2013-08-07 10:49:30 +0000
@@ -184,6 +184,7 @@
     auto compositor = conf.the_compositor();
 
     compositor->start();
+    session.default_surface()->allow_framedropping(true);
 
     std::thread client_thread{
         [&session]

=== modified file 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/shell/test_session_manager.cpp	2013-07-25 23:02:51 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-08-07 10:49:30 +0000
@@ -25,7 +25,6 @@
 #include "mir/shell/null_session_listener.h"
 #include "mir/surfaces/buffer_stream.h"
 #include "mir/surfaces/surface.h"
-#include "mir/compositor/buffer_swapper.h"
 #include "mir/shell/surface_creation_parameters.h"
 
 #include "mir_test/gmock_fixes.h"

=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2013-07-31 11:18:25 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2013-08-07 10:49:30 +0000
@@ -17,9 +17,7 @@
  */
 
 #include "mir/graphics/graphic_buffer_allocator.h"
-#include "mir/compositor/swapper_factory.h"
 #include "src/server/compositor/switching_bundle.h"
-#include "mir/compositor/buffer_swapper_multi.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/buffer_basic.h"
@@ -29,7 +27,6 @@
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/mock_swapper_factory.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/stub_display_buffer.h"
@@ -219,36 +216,7 @@
 
 TEST_F(SurfaceLoop, creating_a_client_surface_allocates_buffer_swapper_on_server)
 {
-    struct ServerConfig : TestingServerConfiguration
-    {
-        std::shared_ptr<mc::BufferAllocationStrategy> the_buffer_allocation_strategy()
-        {
-            using namespace testing;
-
-            if (!buffer_allocation_strategy)
-            {
-                using testing::_;
-                buffer_allocation_strategy = std::make_shared<mtd::MockSwapperFactory>();
-
-                EXPECT_CALL(*buffer_allocation_strategy, create_swapper_new_buffers(_,_,_))
-                    .WillOnce(testing::Invoke(this, &ServerConfig::on_create_swapper));
-            }
-                return buffer_allocation_strategy;
-        }
-
-        std::shared_ptr<mc::BufferSwapper> on_create_swapper(mg::BufferProperties& actual,
-                                                             mg::BufferProperties const& requested,
-                                                             mc::SwapperType)
-        {
-            actual = requested;
-            auto stub_buffer_a = std::make_shared<mtd::StubBuffer>(::buffer_properties);
-            auto stub_buffer_b = std::make_shared<mtd::StubBuffer>(::buffer_properties);
-            std::vector<std::shared_ptr<mg::Buffer>> list = {stub_buffer_a, stub_buffer_b};
-            return std::make_shared<mc::BufferSwapperMulti>(list, list.size());
-        }
-
-        std::shared_ptr<mtd::MockSwapperFactory> buffer_allocation_strategy;
-    } server_config;
+    TestingServerConfiguration server_config;
 
     launch_server_process(server_config);
 
@@ -316,10 +284,11 @@
         std::shared_ptr<mg::GraphicBufferAllocator> create_buffer_allocator(
             const std::shared_ptr<mg::BufferInitializer>& /*buffer_initializer*/) override
         {
-            using testing::AtLeast;
+            using testing::AtMost;
 
             auto buffer_allocator = std::make_shared<testing::NiceMock<MockGraphicBufferAllocator>>();
-            EXPECT_CALL(*buffer_allocator, alloc_buffer(buffer_properties)).Times(AtLeast(2));
+            EXPECT_CALL(*buffer_allocator, alloc_buffer(buffer_properties))
+                .Times(AtMost(3));
             return buffer_allocator;
         }
 
@@ -474,8 +443,8 @@
     {
         void on_exit() override
         {
-            EXPECT_EQ(2*ClientConfigCommon::max_surface_count, CountingStubBuffer::buffers_created.load());
-            EXPECT_EQ(2*ClientConfigCommon::max_surface_count, CountingStubBuffer::buffers_destroyed.load());
+            EXPECT_EQ(CountingStubBuffer::buffers_created.load(),
+                      CountingStubBuffer::buffers_destroyed.load());
         }
 
     } server_config;
@@ -523,8 +492,8 @@
     {
         void on_exit() override
         {
-            EXPECT_EQ(2*ClientConfigCommon::max_surface_count, CountingStubBuffer::buffers_created.load());
-            EXPECT_EQ(2*ClientConfigCommon::max_surface_count, CountingStubBuffer::buffers_destroyed.load());
+            EXPECT_EQ(CountingStubBuffer::buffers_created.load(),
+                      CountingStubBuffer::buffers_destroyed.load());
         }
 
     } server_config;

=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2013-07-31 14:21:34 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2013-08-07 10:49:30 +0000
@@ -1,16 +1,10 @@
 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_buffer_swapper.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_swapper_double.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_swapper_triple.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_swapper_spin_triple.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_temporary_buffers.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_swapper_factory.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_rendering_operator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_switching_bundle.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_rw_lock.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gl_renderer.cpp
 )
 

=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2013-07-31 11:00:22 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2013-08-07 10:49:30 +0000
@@ -34,10 +34,14 @@
 class BufferStreamTest : public ::testing::Test
 {
 protected:
-    virtual void SetUp()
+    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;
@@ -73,12 +77,20 @@
 TEST_F(BufferStreamTest, force_requests_to_complete)
 {
     EXPECT_CALL(*mock_bundle, force_requests_to_complete())
-        .Times(1);
+        .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;

=== removed file 'tests/unit-tests/compositor/test_buffer_swapper.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper.cpp	2013-07-17 16:31:45 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper.cpp	1970-01-01 00:00:00 +0000
@@ -1,156 +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 "mir/compositor/buffer_swapper_multi.h"
-#include "mir_test_doubles/stub_buffer.h"
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-
-struct BufferSwapperConstruction : testing::Test
-{
-    BufferSwapperConstruction()
-    {
-        buffer_a = std::make_shared<mtd::StubBuffer>();
-        buffer_b = std::make_shared<mtd::StubBuffer>();
-        buffer_c = std::make_shared<mtd::StubBuffer>();
-    }
-
-    std::shared_ptr<mg::Buffer> buffer_a;
-    std::shared_ptr<mg::Buffer> buffer_b;
-    std::shared_ptr<mg::Buffer> buffer_c;
-};
-
-TEST_F(BufferSwapperConstruction, basic_double_construction_vector)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
-
-    auto use_count_before_a  = buffer_a.use_count();
-    auto use_count_before_b  = buffer_b.use_count();
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    EXPECT_EQ(buffer_a.use_count(), use_count_before_a + 1);
-    EXPECT_EQ(buffer_b.use_count(), use_count_before_b + 1);
-
-    /* just to keep ref */
-    swapper.force_client_abort();
-}
-
-TEST_F(BufferSwapperConstruction, basic_double_construction_initializer)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b};
-
-    auto use_count_before_a  = buffer_a.use_count();
-    auto use_count_before_b  = buffer_b.use_count();
-
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    EXPECT_EQ(buffer_a.use_count(), use_count_before_a + 1);
-    EXPECT_EQ(buffer_b.use_count(), use_count_before_b + 1);
-
-    /* just to keep ref */
-    swapper.force_client_abort();
-}
-
-TEST_F(BufferSwapperConstruction, basic_triple_construction_initializer)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
-    auto use_count_before_a  = buffer_a.use_count();
-    auto use_count_before_b  = buffer_b.use_count();
-    auto use_count_before_c  = buffer_c.use_count();
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    EXPECT_EQ(buffer_a.use_count(), use_count_before_a + 1);
-    EXPECT_EQ(buffer_b.use_count(), use_count_before_b + 1);
-    EXPECT_EQ(buffer_c.use_count(), use_count_before_c + 1);
-
-    /* just to keep ref */
-    swapper.force_client_abort();
-}
-
-TEST_F(BufferSwapperConstruction, buffers_out_come_from_init_double)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b};
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    auto buffer_1 = swapper.compositor_acquire();
-    auto buffer_2 = swapper.client_acquire();
-    /* swapper is now 'empty' */
-
-    EXPECT_TRUE((buffer_a == buffer_1) || (buffer_b == buffer_1) );
-    EXPECT_TRUE((buffer_a == buffer_2) || (buffer_b == buffer_2) );
-}
-
-TEST_F(BufferSwapperConstruction, buffers_out_come_from_init_triple)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    auto buffer_1 = swapper.compositor_acquire();
-    auto buffer_2 = swapper.client_acquire();
-    swapper.client_release(buffer_2);
-    auto buffer_3 = swapper.client_acquire();
-    /* swapper is now 'empty' */
-
-    EXPECT_TRUE((buffer_a == buffer_1) || (buffer_b == buffer_1) || (buffer_c == buffer_1));
-    EXPECT_TRUE((buffer_a == buffer_2) || (buffer_b == buffer_2) || (buffer_c == buffer_2));
-    EXPECT_TRUE((buffer_a == buffer_3) || (buffer_b == buffer_3) || (buffer_c == buffer_3));
-}
-
-
-TEST_F(BufferSwapperConstruction, buffer_transfer_triple_all_owned)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    size_t test_size;
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    swapper.end_responsibility(list, test_size);
-
-    auto res1 = std::find(list.begin(), list.end(), buffer_a);
-    auto res2 = std::find(list.begin(), list.end(), buffer_b);
-    auto res3 = std::find(list.begin(), list.end(), buffer_c);
-    EXPECT_EQ(3u, list.size());
-    EXPECT_NE(list.end(), res1);
-    EXPECT_NE(list.end(), res2);
-    EXPECT_NE(list.end(), res3);
-
-    EXPECT_EQ(3u, test_size);
-}
-
-TEST_F(BufferSwapperConstruction, buffer_transfer_triple_some_not_owned)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> buffers{buffer_a, buffer_b, buffer_c};
-    mc::BufferSwapperMulti swapper(buffers, buffers.size());
-
-    auto acquired_buffer = swapper.client_acquire();
-
-    size_t test_size;
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    swapper.end_responsibility(list, test_size);
-
-    auto res1 = std::find(list.begin(), list.end(), acquired_buffer);
-    EXPECT_EQ(2u, list.size());
-    EXPECT_EQ(list.end(), res1); //acquired_buffer should not be in list
-
-    EXPECT_EQ(3u, test_size);
-}

=== removed file 'tests/unit-tests/compositor/test_buffer_swapper_double.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_double.cpp	2013-07-17 16:38:25 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_double.cpp	1970-01-01 00:00:00 +0000
@@ -1,207 +0,0 @@
-/*
- * Copyright © 2012, 2013 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 "mir_test_doubles/stub_buffer.h"
-
-#include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/graphics/buffer_id.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <future>
-#include <thread>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-
-namespace
-{
-struct BufferSwapperDouble : testing::Test
-{
-    void SetUp()
-    {
-        buffer_a = std::make_shared<mtd::StubBuffer>();
-        buffer_b = std::make_shared<mtd::StubBuffer>();
-
-        auto double_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b};
-        swapper = std::make_shared<mc::BufferSwapperMulti>(double_list, double_list.size());
-
-    }
-
-    std::shared_ptr<mg::Buffer> buffer_a;
-    std::shared_ptr<mg::Buffer> buffer_b;
-
-    std::shared_ptr<mc::BufferSwapper> swapper;
-};
-
-}
-
-TEST_F(BufferSwapperDouble, test_valid_buffer_returned)
-{
-    auto buffer = swapper->client_acquire();
-
-    EXPECT_TRUE((buffer == buffer_a) || (buffer == buffer_b));
-}
-
-TEST_F(BufferSwapperDouble, test_valid_and_unique_with_two_acquires)
-{
-    auto buffer_1 = swapper->client_acquire();
-    swapper->client_release(buffer_1);
-
-    auto buffer_tmp = swapper->compositor_acquire();
-    swapper->compositor_release(buffer_tmp);
-
-    auto buffer_2 = swapper->client_acquire();
-    swapper->client_release(buffer_2);
-
-    EXPECT_NE(buffer_1, buffer_2);
-
-    EXPECT_TRUE((buffer_1 == buffer_a) || (buffer_1 == buffer_b));
-    EXPECT_TRUE((buffer_2 == buffer_a) || (buffer_2 == buffer_b));
-}
-
-TEST_F(BufferSwapperDouble, test_compositor_gets_valid)
-{
-    auto buffer = swapper->compositor_acquire();
-    EXPECT_TRUE((buffer == buffer_a) || (buffer == buffer_b));
-}
-
-TEST_F(BufferSwapperDouble, test_compositor_gets_last_posted)
-{
-    auto buffer_1 = swapper->client_acquire();
-    swapper->client_release(buffer_1);
-
-    auto buffer_2 = swapper->compositor_acquire();
-    swapper->compositor_release(buffer_2);
-
-    EXPECT_EQ(buffer_1, buffer_2);
-}
-
-TEST_F(BufferSwapperDouble, test_two_grabs_without_a_client_release)
-{
-    swapper->client_acquire();
-
-    auto buffer_1 = swapper->compositor_acquire();
-    swapper->compositor_release(buffer_1);
-
-    auto buffer_2 = swapper->compositor_acquire();
-    EXPECT_EQ(buffer_1, buffer_2);
-}
-
-TEST_F(BufferSwapperDouble, test_client_and_compositor_advance_buffers_in_serial_pattern)
-{
-    auto buffer_1 = swapper->client_acquire();
-    swapper->client_release(buffer_1);
-
-    auto buffer_2 = swapper->compositor_acquire();
-    swapper->compositor_release(buffer_2);
-
-    auto buffer_3 = swapper->client_acquire();
-    swapper->client_release(buffer_3);
-
-    auto buffer_4 = swapper->compositor_acquire();
-
-    EXPECT_NE(buffer_1, buffer_3);
-    EXPECT_NE(buffer_2, buffer_4);
-}
-
-TEST_F(BufferSwapperDouble, force_client_abort_works_causes_rc_failure)
-{
-    auto client_buffer = swapper->client_acquire();
-    swapper->client_release(client_buffer);
-
-    client_buffer = swapper->client_acquire();
-    swapper->client_release(client_buffer);
-
-    /*
-     * Unblock the the upcoming client_acquire() call. There is no guarantee
-     * that force_client_abort will run after client_acquire() is
-     * blocked, but it doesn't matter. As long as the client uses only one
-     * buffer at a time, BufferSwapperMulti::force_client_abort() ensures
-     * that either a currently blocked request will unblock, or the next
-     * request will not block.
-     */
-    auto f = std::async(std::launch::async,
-                [this]
-                {
-                    std::this_thread::sleep_for(std::chrono::milliseconds{10});
-                    swapper->force_client_abort();
-                });
-
-    EXPECT_THROW({
-        swapper->client_acquire();
-    }, std::runtime_error);
-}
-
-TEST_F(BufferSwapperDouble, force_client_abort_works)
-{
-    swapper->client_acquire();
-
-    auto f = std::async(std::launch::async,
-                [this]
-                {
-                    std::this_thread::sleep_for(std::chrono::milliseconds{10});
-                    swapper->force_client_abort();
-                });
-
-    EXPECT_THROW({
-        swapper->client_acquire();
-    }, std::runtime_error);
-}
-
-TEST_F(BufferSwapperDouble, force_requests_to_complete_works)
-{
-    auto client_buffer = swapper->client_acquire();
-    swapper->client_release(client_buffer);
-
-    /*
-     * Unblock the the upcoming client_acquire() call. There is no guarantee
-     * that force_requests_to_complete will run after client_acquire() is
-     * blocked, but it doesn't matter. As long as the client uses only one
-     * buffer at a time, BufferSwapperMulti::force_requests_to_complete() ensures
-     * that either a currently blocked request will unblock, or the next
-     * request will not block.
-     */
-    auto f = std::async(std::launch::async,
-                 [this]
-                 {
-                     std::this_thread::sleep_for(std::chrono::milliseconds{10});
-                     swapper->force_requests_to_complete();
-                 });
-
-    client_buffer = swapper->client_acquire();
-
-    EXPECT_NE(nullptr, client_buffer);
-}
-
-TEST_F(BufferSwapperDouble, force_requests_to_complete_throws_if_all_buffers_are_acquired)
-{
-    auto client_buffer = swapper->client_acquire();
-    swapper->client_release(client_buffer);
-
-    client_buffer = swapper->client_acquire();
-    auto comp_buffer = swapper->compositor_acquire();
-
-    EXPECT_THROW({
-        swapper->force_requests_to_complete();
-    }, std::logic_error);
-}

=== removed file 'tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp	2013-07-17 16:31:45 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_spin_triple.cpp	1970-01-01 00:00:00 +0000
@@ -1,213 +0,0 @@
-/*
- * Copyright © 2013 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 "mir/compositor/buffer_swapper_spin.h"
-
-#include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/mock_swapper.h"
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace mtd = mir::test::doubles;
-
-namespace
-{
-
-struct BufferSwapperSpinTriple : testing::Test
-{
-    BufferSwapperSpinTriple()
-        : buffer_a{std::make_shared<mtd::StubBuffer>()},
-          buffer_b{std::make_shared<mtd::StubBuffer>()},
-          buffer_c{std::make_shared<mtd::StubBuffer>()}
-    {
-          auto list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
-          swapper = std::make_shared<mc::BufferSwapperSpin>(list, list.size());
-    }
-
-    std::shared_ptr<mg::Buffer> const buffer_a;
-    std::shared_ptr<mg::Buffer> const buffer_b;
-    std::shared_ptr<mg::Buffer> const buffer_c;
-
-    std::shared_ptr<mc::BufferSwapper> swapper;
-};
-
-}
-
-TEST_F(BufferSwapperSpinTriple, client_can_always_get_new_buffer)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> expected_buffers;
-
-    for (unsigned int i = 0; i < 10; i++)
-    {
-        auto buf = swapper->client_acquire();
-
-        /* Check that the client doesn't reuse a buffer until there is no choice */
-        if (expected_buffers.empty())
-        {
-            expected_buffers.push_back(buffer_a);
-            expected_buffers.push_back(buffer_b);
-            expected_buffers.push_back(buffer_c);
-        }
-
-        auto buf_iter = std::find(expected_buffers.begin(), expected_buffers.end(), buf);
-        bool acquired_buf_in_expected_buffers = (buf_iter != expected_buffers.end());
-
-        EXPECT_TRUE(acquired_buf_in_expected_buffers) << "buf: " << buf;
-
-        if (acquired_buf_in_expected_buffers)
-            expected_buffers.erase(buf_iter);
-
-        swapper->client_release(buf);
-    }
-}
-
-TEST_F(BufferSwapperSpinTriple, client_can_always_get_new_buffer_while_compositor_has_one)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> expected_buffers;
-
-    auto comp_buf = swapper->compositor_acquire();
-
-    for (unsigned int i = 0; i < 10; i++)
-    {
-        auto buf = swapper->client_acquire();
-
-        /* Check that the client doesn't reuse a buffer until there is no choice */
-        if (expected_buffers.empty())
-        {
-            if (comp_buf != buffer_a)
-                expected_buffers.push_back(buffer_a);
-            if (comp_buf != buffer_b)
-                expected_buffers.push_back(buffer_b);
-            if (comp_buf != buffer_c)
-                expected_buffers.push_back(buffer_c);
-        }
-
-        auto buf_iter = std::find(expected_buffers.begin(), expected_buffers.end(), buf);
-        bool acquired_buf_in_expected_buffers = (buf_iter != expected_buffers.end());
-
-        EXPECT_TRUE(acquired_buf_in_expected_buffers) << "buf: " << buf;
-
-        if (acquired_buf_in_expected_buffers)
-            expected_buffers.erase(buf_iter);
-
-        swapper->client_release(buf);
-    }
-
-    swapper->compositor_release(comp_buf);
-}
-
-TEST_F(BufferSwapperSpinTriple, compositor_gets_last_posted_client_buffer)
-{
-    auto buf_a = swapper->client_acquire();
-    swapper->client_release(buf_a);
-
-    auto comp_buf1 = swapper->compositor_acquire();
-    swapper->compositor_release(comp_buf1);
-
-    EXPECT_EQ(buf_a, comp_buf1);
-
-    auto comp_buf2 = swapper->compositor_acquire();
-    swapper->compositor_release(comp_buf2);
-
-    EXPECT_EQ(buf_a, comp_buf2);
-}
-
-TEST_F(BufferSwapperSpinTriple, compositor_gets_last_posted_client_buffer_interleaved)
-{
-    auto buf_a = swapper->client_acquire();
-    swapper->client_release(buf_a);
-
-    auto comp_buf1 = swapper->compositor_acquire();
-
-    auto buf_b = swapper->client_acquire();
-    swapper->client_release(buf_b);
-
-    swapper->compositor_release(comp_buf1);
-
-    EXPECT_EQ(buf_a, comp_buf1);
-
-    auto comp_buf2 = swapper->compositor_acquire();
-    swapper->compositor_release(comp_buf2);
-
-    EXPECT_EQ(buf_b, comp_buf2);
-}
-
-TEST_F(BufferSwapperSpinTriple, compositor_release_makes_buffer_available_to_client)
-{
-    auto comp_buf = swapper->compositor_acquire();
-
-    /* Check that the compositor's buffer is not available to the client */
-    for (auto i = 0; i < 3; i++)
-    {
-        auto buf = swapper->client_acquire();
-        EXPECT_NE(comp_buf, buf);
-        swapper->client_release(buf);
-    }
-
-    swapper->compositor_release(comp_buf);
-
-    /* After the release, the compositor's buffer should be available to the client */
-    std::vector<std::shared_ptr<mg::Buffer>> client_buffers;
-
-    for (auto i = 0; i < 3; i++)
-    {
-        auto buf = swapper->client_acquire();
-        client_buffers.push_back(buf);
-        swapper->client_release(buf);
-    }
-
-    EXPECT_TRUE(client_buffers[0] == comp_buf ||
-                client_buffers[1] == comp_buf ||
-                client_buffers[2] == comp_buf);
-}
-    
-TEST_F(BufferSwapperSpinTriple, buffer_transfer_triple_all_owned)
-{
-    size_t test_size;
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    swapper->end_responsibility(list, test_size);
-
-    auto res1 = std::find(list.begin(), list.end(), buffer_a);
-    auto res2 = std::find(list.begin(), list.end(), buffer_b);
-    auto res3 = std::find(list.begin(), list.end(), buffer_c);
-    EXPECT_EQ(3u, list.size());
-    EXPECT_NE(list.end(), res1);
-    EXPECT_NE(list.end(), res2);
-    EXPECT_NE(list.end(), res3);
-
-    EXPECT_EQ(3u, test_size);
-}
-
-TEST_F(BufferSwapperSpinTriple, buffer_transfer_triple_some_not_owned)
-{
-    auto acquired_buffer = swapper->client_acquire();
-
-    size_t test_size;
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    swapper->end_responsibility(list, test_size);
-
-    auto res1 = std::find(list.begin(), list.end(), acquired_buffer);
-    EXPECT_EQ(2u, list.size());
-    EXPECT_EQ(list.end(), res1); //acquired_buffer should not be in list
-
-    EXPECT_EQ(3u, test_size);
-}

=== removed file 'tests/unit-tests/compositor/test_buffer_swapper_triple.cpp'
--- tests/unit-tests/compositor/test_buffer_swapper_triple.cpp	2013-07-17 16:38:25 +0000
+++ tests/unit-tests/compositor/test_buffer_swapper_triple.cpp	1970-01-01 00:00:00 +0000
@@ -1,125 +0,0 @@
-/*
- * Copyright © 2012, 2013 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 "mir_test_doubles/stub_buffer.h"
-
-#include "mir/compositor/buffer_swapper_multi.h"
-#include "mir/graphics/buffer_id.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-namespace
-{
-
-struct BufferSwapperTriple : testing::Test
-{
-    void SetUp()
-    {
-        buffer_a = std::make_shared<mtd::StubBuffer>();
-        buffer_b = std::make_shared<mtd::StubBuffer>();
-        buffer_c = std::make_shared<mtd::StubBuffer>();
-
-        auto triple_list = std::vector<std::shared_ptr<mg::Buffer>>{buffer_a, buffer_b, buffer_c};
-        swapper = std::make_shared<mc::BufferSwapperMulti>(triple_list, triple_list.size());
-
-    }
-
-    std::shared_ptr<mg::Buffer> buffer_a;
-    std::shared_ptr<mg::Buffer> buffer_b;
-    std::shared_ptr<mg::Buffer> buffer_c;
-
-    std::shared_ptr<mc::BufferSwapper> swapper;
-};
-
-}
-
-TEST_F(BufferSwapperTriple, test_valid_buffer_returned)
-{
-    auto buf = swapper->client_acquire();
-
-    EXPECT_TRUE((buf == buffer_a) || (buf == buffer_b) || (buf = buffer_c));
-}
-
-TEST_F(BufferSwapperTriple, test_valid_and_unique_with_two_acquires)
-{
-    auto buffer_1 = swapper->client_acquire();
-    swapper->client_release(buffer_1);
-
-    //just so one thread operation is ok
-    auto buffer_tmp = swapper->compositor_acquire();
-    swapper->compositor_release(buffer_tmp);
-
-    auto buffer_2 = swapper->client_acquire();
-    swapper->client_release(buffer_2);
-
-    auto buffer_3 = swapper->client_acquire();
-    swapper->client_release(buffer_3);
-
-    EXPECT_NE(buffer_1, buffer_2);
-    EXPECT_NE(buffer_1, buffer_3);
-    EXPECT_NE(buffer_2, buffer_3);
-}
-
-TEST_F(BufferSwapperTriple, test_compositor_gets_clients_last_buffer)
-{
-    auto buffer_a = swapper->client_acquire();
-    swapper->client_release(buffer_a);
-
-    auto comp_buffer = swapper->compositor_acquire();
-    EXPECT_EQ(buffer_a, comp_buffer);
-}
-
-/* this would stall a double buffer */
-TEST_F(BufferSwapperTriple, test_client_can_get_two_buffers_without_compositor_consuming_two_buffers)
-{
-    auto buffer_1 = swapper->compositor_acquire();
-
-    auto buffer_2 = swapper->client_acquire();
-    swapper->client_release(buffer_2);
-
-    auto buffer_3 = swapper->client_acquire();
-    swapper->client_release(buffer_3);
-
-    EXPECT_NE(buffer_2, buffer_3);
-}
-
-TEST_F(BufferSwapperTriple, test_compositor_gets_last_posted_in_order)
-{
-    auto first_comp_buffer = swapper->compositor_acquire();
-
-    auto first_client_buffer = swapper->client_acquire();
-    swapper->client_release(first_client_buffer);
-
-    auto second_client_buffer = swapper->client_acquire();
-    swapper->client_release(second_client_buffer);
-
-    swapper->compositor_release(first_comp_buffer);
-
-    auto second_comp_buffer = swapper->compositor_acquire();
-    swapper->compositor_release(second_comp_buffer);
-
-    auto third_comp_buffer = swapper->compositor_acquire();
-
-    EXPECT_EQ(second_comp_buffer, first_client_buffer);
-    EXPECT_EQ(third_comp_buffer, second_client_buffer);
-}

=== removed file 'tests/unit-tests/compositor/test_rw_lock.cpp'
--- tests/unit-tests/compositor/test_rw_lock.cpp	2013-06-07 15:23:27 +0000
+++ tests/unit-tests/compositor/test_rw_lock.cpp	1970-01-01 00:00:00 +0000
@@ -1,173 +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/rw_lock.h"
-#include <gtest/gtest.h>
-#include <vector>
-#include <future>
-#include <thread>
-
-namespace mc=mir::compositor;
-TEST(RWLockWriterBiasTest, multi_readers_dont_block)
-{
-    int const num_asyncs = 33;
-
-    mc::RWLockWriterBias lock;
-    int locked_value = 45;
-
-    std::vector<std::future<int>> asyncs;
-
-    {
-        std::unique_lock<mc::ReadLock> lk(lock);
-        for(auto i = 0; i < num_asyncs; i++)
-        {
-            asyncs.push_back(std::async(std::launch::async,
-                [&]
-                {
-                    std::unique_lock<mc::ReadLock> lk(lock);
-                    return locked_value; 
-                }));
-        }
-
-        for(auto& i : asyncs)
-        {
-            i.wait(); 
-        }
-    }
-
-    for(auto& i : asyncs)
-    {
-        EXPECT_EQ(locked_value, i.get()); 
-    }
-}
-
-TEST(RWLockWriterBiasTest, multi_writers)
-{
-    int const num_asyncs = 10, num_loops = 100;
-
-    mc::RWLockWriterBias lock;
-    int locked_value = 0;
-
-    std::vector<std::future<void>> asyncs;
-    for(auto i = 0; i < num_asyncs; i++)
-    {
-        asyncs.push_back(std::async(std::launch::async,
-            [&]
-            {
-                std::unique_lock<mc::WriteLock> lk(lock);
-                for(auto j=0; j < num_loops; j++)
-                {
-                    locked_value++;
-                }
-            }));
-    }
-
-    for(auto& i : asyncs)
-    {
-        i.wait(); 
-    }
-
-    EXPECT_EQ(num_asyncs * num_loops, locked_value); 
-}
-
-TEST(RWLockWriterBiasTest, writers_force_wait)
-{
-    int const num_asyncs = 100;
-    int const before = 66;
-    int const increment = 1000;
-    int const after = before + increment;
-    int locked_value = before;
-    std::vector<std::future<int>> reader_asyncs;
-
-    mc::RWLockWriterBias lock;
-
-    {
-        std::unique_lock<mc::WriteLock> lk(lock);
-        
-        /* since all the readers are fired off while the write lock is held,
-           they should all return the 'after' value*/
-        for(auto i = 0; i < num_asyncs; i++)
-        {
-            reader_asyncs.push_back(std::async(std::launch::async,
-                [&]
-                {
-                    std::unique_lock<mc::ReadLock> lk(lock);
-                    return locked_value;
-                }));
-        }
-
-        for(auto i=0; i < increment; i++)
-        {
-            locked_value++;
-        } 
-    }
-
-    for(auto& i : reader_asyncs)
-    {
-        i.wait();
-        EXPECT_EQ(after, i.get());
-    }
-}
-
-TEST(RWLockWriterBiasTest, readers_and_writers)
-{
-    int const num_asyncs = 10;
-    std::vector<std::future<int>> reader_asyncs;
-
-    mc::RWLockWriterBias lock;
-    int const before = 66, after = 1066;
-    int locked_value = before;
-
-    for(auto i = 0; i < num_asyncs; i++)
-    {
-        reader_asyncs.push_back(std::async(std::launch::async,
-            [&]
-            {
-                std::unique_lock<mc::ReadLock> lk(lock);
-                return locked_value; 
-            }));
-    }
-
-    auto writer_async = std::async(std::launch::async,
-        [&]
-        {
-            std::unique_lock<mc::WriteLock> lk(lock);
-            for(auto j=0; j<1000; j++)
-            {
-                locked_value++;
-            }
-        });
-    writer_async.wait();
-
-    for(auto i = 0; i < num_asyncs; i++)
-    {
-        reader_asyncs.push_back(std::async(std::launch::async,
-            [&]
-            {
-                std::unique_lock<mc::ReadLock> lk(lock);
-                return locked_value; 
-            }));
-    }
-
-    for(auto& i : reader_asyncs)
-    {
-        i.wait();
-        auto value = i.get();
-        EXPECT_TRUE( ((value == before) || (value == after)) ); 
-    }
-}

=== removed file 'tests/unit-tests/compositor/test_swapper_factory.cpp'
--- tests/unit-tests/compositor/test_swapper_factory.cpp	2013-07-31 11:18:25 +0000
+++ tests/unit-tests/compositor/test_swapper_factory.cpp	1970-01-01 00:00:00 +0000
@@ -1,221 +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: Alexandros Frantzis <[e-mail]>
- */
-
-#include "mir/compositor/swapper_factory.h"
-#include "mir/graphics/buffer_basic.h"
-#include "mir/graphics/buffer_properties.h"
-#include "mir/compositor/buffer_swapper.h"
-#include "mir/graphics/graphic_buffer_allocator.h"
-#include "mir_test_doubles/stub_buffer.h"
-#include "src/server/compositor/buffer_bundle.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
-
-namespace
-{
-static geom::Size const buf_size{100, 121};
-static geom::PixelFormat const buf_pixel_format{geom::PixelFormat::xbgr_8888};
-
-class MockGraphicBufferAllocator : public mg::GraphicBufferAllocator
-{
-public:
-    MockGraphicBufferAllocator()
-    {
-        using namespace testing;
-        mg::BufferProperties properties(buf_size, buf_pixel_format, mg::BufferUsage::hardware);
-        ON_CALL(*this, alloc_buffer(_))
-            .WillByDefault(Return(std::make_shared<mtd::StubBuffer>(properties)));
-    }
-    MOCK_METHOD1(alloc_buffer, std::shared_ptr<mg::Buffer>(mg::BufferProperties const&));
-    MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
-
-    ~MockGraphicBufferAllocator() noexcept {}
-};
-
-struct SwapperFactoryTest : testing::Test
-{
-    SwapperFactoryTest()
-        : mock_buffer_allocator{std::make_shared<testing::NiceMock<MockGraphicBufferAllocator>>()},
-          size{10, 20},
-          pf{geom::PixelFormat::abgr_8888},
-          usage{mg::BufferUsage::hardware},
-          properties{size, pf, usage}
-
-    {
-    }
-
-    std::shared_ptr<MockGraphicBufferAllocator> const mock_buffer_allocator;
-    geom::Size const size;
-    geom::PixelFormat const pf;
-    mg::BufferUsage const usage;
-    mg::BufferProperties const properties;
-};
-}
-
-/* default number of buffers is 2 */
-TEST_F(SwapperFactoryTest, create_sync_uses_default_number_of_buffers)
-{
-    using namespace testing;
-
-    mg::BufferProperties actual_properties;
-    int default_num_of_buffers = 2;
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(default_num_of_buffers);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator);
-    auto swapper = strategy.create_swapper_new_buffers(
-        actual_properties, properties, mc::SwapperType::synchronous);
-}
-
-TEST_F(SwapperFactoryTest, create_sync_with_two_makes_double_buffer)
-{
-    using namespace testing;
-
-    int num_of_buffers = 2;
-    mg::BufferProperties actual_properties;
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(num_of_buffers);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator, num_of_buffers);
-    auto swapper = strategy.create_swapper_new_buffers(
-        actual_properties, properties, mc::SwapperType::synchronous);
-}
-
-TEST_F(SwapperFactoryTest, create_sync_with_three_makes_triple_buffer)
-{
-    using namespace testing;
-
-    int num_of_buffers = 3;
-    mg::BufferProperties actual_properties;
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(num_of_buffers);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator, num_of_buffers);
-    auto swapper = strategy.create_swapper_new_buffers(
-        actual_properties, properties, mc::SwapperType::synchronous);
-}
-
-TEST_F(SwapperFactoryTest, create_async_ignores_preference)
-{
-    using namespace testing;
-
-    mg::BufferProperties actual_properties;
-
-    int num_of_buffers = 3;
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(num_of_buffers);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator);
-    auto swapper = strategy.create_swapper_new_buffers(
-        actual_properties, properties, mc::SwapperType::framedropping);
-}
-
-TEST_F(SwapperFactoryTest, creation_returns_new_parameters)
-{
-    mg::BufferProperties actual1, actual2;
-    mc::SwapperFactory strategy(mock_buffer_allocator);
-    strategy.create_swapper_new_buffers(actual1, properties, mc::SwapperType::synchronous);
-
-    EXPECT_EQ(buf_size, actual1.size);
-    EXPECT_EQ(buf_pixel_format, actual1.format);
-    EXPECT_EQ(usage, actual1.usage);
-}
-
-TEST_F(SwapperFactoryTest, create_async_reuse)
-{
-    using namespace testing;
-
-    mg::BufferProperties properties;
-    std::vector<std::shared_ptr<mg::Buffer>> list {};
-    size_t size = 3;
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(0);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator);
-    auto swapper = strategy.create_swapper_reuse_buffers(properties, list, size, mc::SwapperType::framedropping);
-}
-
-TEST_F(SwapperFactoryTest, create_sync_reuse)
-{
-    using namespace testing;
-
-    mg::BufferProperties properties;
-    std::vector<std::shared_ptr<mg::Buffer>> list;
-    size_t size = 3;
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(properties))
-        .Times(0);
-
-    mc::SwapperFactory strategy(mock_buffer_allocator, 3);
-    auto swapper = strategy.create_swapper_reuse_buffers(properties, list, size, mc::SwapperType::synchronous);
-}
-
-TEST_F(SwapperFactoryTest, reuse_drop_unneeded_buffer)
-{
-    using namespace testing;
-
-    mc::SwapperFactory strategy(mock_buffer_allocator, 2);
-
-    auto buffer = std::make_shared<mtd::StubBuffer>();
-    {
-        size_t size = 3;
-        std::vector<std::shared_ptr<mg::Buffer>> list{buffer};
-
-        auto swapper = strategy.create_swapper_reuse_buffers(
-            properties, list, size, mc::SwapperType::synchronous);
-    }
-    EXPECT_EQ(1, buffer.use_count());
-}
-
-TEST_F(SwapperFactoryTest, reuse_drop_unneeded_buffer_error)
-{
-    using namespace testing;
-
-    mc::SwapperFactory strategy(mock_buffer_allocator, 2);
-
-    size_t size = 3;
-    std::vector<std::shared_ptr<mg::Buffer>> list{};
-
-    EXPECT_THROW({
-        strategy.create_swapper_reuse_buffers(
-            properties, list, size, mc::SwapperType::synchronous);
-    }, std::logic_error);
-}
-
-TEST_F(SwapperFactoryTest, reuse_alloc_additional_buffer_for_framedropping)
-{
-    using namespace testing;
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer(_))
-        .Times(1);
-    mc::SwapperFactory strategy(mock_buffer_allocator);
-
-    size_t size = 2;
-    std::vector<std::shared_ptr<mg::Buffer>> list{};
-    auto swapper = strategy.create_swapper_reuse_buffers(
-        properties, list, size, mc::SwapperType::framedropping);
-}

=== modified file 'tests/unit-tests/compositor/test_switching_bundle.cpp'
--- tests/unit-tests/compositor/test_switching_bundle.cpp	2013-07-31 11:00:22 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2013-08-07 10:49:30 +0000
@@ -13,144 +13,704 @@
  * 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]>
+ * Authored by: Daniel van Vugt <[e-mail]>
  */
 
 #include "src/server/compositor/switching_bundle.h"
-#include "mir/compositor/swapper_factory.h"
+#include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_buffer.h"
-#include "mir_test_doubles/mock_swapper.h"
-#include "mir_test_doubles/mock_swapper_factory.h"
 
 #include <gtest/gtest.h>
 
+#include <atomic>
+#include <thread>
+#include <chrono>
+
 namespace geom=mir::geometry;
 namespace mtd=mir::test::doubles;
 namespace mc=mir::compositor;
 namespace mg = mir::graphics;
 
+using namespace testing;
+
 struct SwitchingBundleTest : public ::testing::Test
 {
     void SetUp()
     {
-        using namespace testing;
-        mock_swapper_factory = std::make_shared<testing::NiceMock<mtd::MockSwapperFactory>>();
-        mock_default_swapper = std::make_shared<testing::NiceMock<mtd::MockSwapper>>();
-        mock_secondary_swapper = std::make_shared<testing::NiceMock<mtd::MockSwapper>>();
-        stub_buffer = std::make_shared<mtd::StubBuffer>();
-        properties = mg::BufferProperties{geom::Size{4, 2},
-                                          geom::PixelFormat::abgr_8888, mg::BufferUsage::hardware};
-
-        ON_CALL(*mock_swapper_factory, create_swapper_new_buffers(_,_,_))
-            .WillByDefault(Return(mock_default_swapper));
+        allocator = std::make_shared<mtd::StubBufferAllocator>();
+        basic_properties =
+        {
+            geom::Size{3, 4},
+            geom::PixelFormat::abgr_8888,
+            mg::BufferUsage::hardware
+        };
     }
 
-    std::shared_ptr<mtd::MockSwapperFactory> mock_swapper_factory;
-    std::shared_ptr<mtd::MockSwapper> mock_default_swapper;
-    std::shared_ptr<mtd::MockSwapper> mock_secondary_swapper;
-    std::shared_ptr<mg::Buffer> stub_buffer;
-    mg::BufferProperties properties;
+    std::shared_ptr<mtd::StubBufferAllocator> allocator;
+
+    mg::BufferProperties basic_properties;
 };
 
 TEST_F(SwitchingBundleTest, sync_swapper_by_default)
 {
-    using namespace testing;
-    auto actual_properties = mg::BufferProperties{geom::Size{7, 8},
-                                                  geom::PixelFormat::argb_8888, mg::BufferUsage::software};
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_new_buffers(_,_,mc::SwapperType::synchronous))
-        .Times(1)
-        .WillOnce(DoAll(SetArgReferee<0>(actual_properties),
-                        Return(mock_default_swapper)));
-
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-    EXPECT_EQ(actual_properties, switcher.properties());
+    mg::BufferProperties properties{geom::Size{7, 8},
+                                    geom::PixelFormat::argb_8888,
+                                    mg::BufferUsage::software};
+
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, properties);
+
+        EXPECT_FALSE(bundle.framedropping_allowed());
+        EXPECT_EQ(properties, bundle.properties());
+    }
+}
+
+TEST_F(SwitchingBundleTest, invalid_nbuffers)
+{
+    EXPECT_THROW(
+        mc::SwitchingBundle a(0, allocator, basic_properties),
+        std::logic_error
+    );
+
+    EXPECT_THROW(
+        mc::SwitchingBundle b(-1, allocator, basic_properties),
+        std::logic_error
+    );
+
+    EXPECT_THROW(
+        mc::SwitchingBundle c(-123, allocator, basic_properties),
+        std::logic_error
+    );
+
+    EXPECT_THROW(
+        mc::SwitchingBundle d(10, allocator, basic_properties),
+        std::logic_error
+    );
 }
 
 TEST_F(SwitchingBundleTest, client_acquire_basic)
 {
-    using namespace testing;
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-
-    EXPECT_CALL(*mock_default_swapper, client_acquire())
-        .Times(1)
-        .WillOnce(Return(stub_buffer));
-    EXPECT_CALL(*mock_default_swapper, client_release(stub_buffer))
-        .Times(1);
-
-    auto buffer = switcher.client_acquire();
-    switcher.client_release(buffer); 
-}
-
-TEST_F(SwitchingBundleTest, client_acquire_with_switch)
-{
-    using namespace testing;
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-
-    EXPECT_CALL(*mock_default_swapper, client_acquire())
-        .Times(1)
-        .WillOnce(Return(stub_buffer));
-    EXPECT_CALL(*mock_secondary_swapper, client_release(stub_buffer))
-        .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,_))
-        .Times(1)
-        .WillOnce(Return(mock_secondary_swapper));
-
-    auto buffer = switcher.client_acquire();
-    switcher.allow_framedropping(true);
- 
-    switcher.client_release(buffer); 
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto buffer = bundle.client_acquire();
+        bundle.client_release(buffer);
+    }
+}
+
+namespace
+{
+    const int frame_rate = 60;
+    const std::chrono::microseconds frame_time(1000000 / frame_rate);
+
+    void sleep_one_frame()
+    {
+        std::this_thread::sleep_for(frame_time);
+    }
+
+    void composite_thread(mc::SwitchingBundle &bundle,
+                          mg::BufferID &composited)
+    {
+        sleep_one_frame();
+        auto buffer = bundle.compositor_acquire();
+        composited = buffer->id();
+        bundle.compositor_release(buffer);
+    }
+}
+
+TEST_F(SwitchingBundleTest, is_really_synchronous)
+{
+    for (int nbuffers = 1; nbuffers < 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        mg::BufferID prev_id, prev_prev_id;
+
+        ASSERT_FALSE(bundle.framedropping_allowed());
+
+        for (int i = 0; i < 50; i++)
+        {
+            auto client1 = bundle.client_acquire();
+            mg::BufferID expect_id = client1->id(), composited_id;
+            bundle.client_release(client1);
+
+            std::thread compositor(composite_thread,
+                                   std::ref(bundle),
+                                   std::ref(composited_id));
+
+            compositor.join();
+            ASSERT_EQ(expect_id, composited_id);
+
+            if (i >= 2 && nbuffers == 2)
+                ASSERT_EQ(composited_id, prev_prev_id);
+
+            prev_prev_id = prev_id;
+            prev_id = composited_id;
+
+            auto second_monitor = bundle.compositor_acquire();
+            ASSERT_EQ(composited_id, second_monitor->id());
+            bundle.compositor_release(second_monitor);
+        }
+    }
+}
+
+TEST_F(SwitchingBundleTest, framedropping_clients_never_block)
+{
+    for (int nbuffers = 2; nbuffers < 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        bundle.allow_framedropping(true);
+        mg::BufferID last_client_id;
+
+        for (int i = 0; i < 50; i++)
+        {
+            for (int j = 0; j < 100; j++)
+            {
+                auto client = bundle.client_acquire();
+                last_client_id = client->id();
+                bundle.client_release(client);
+            }
+
+            // Flush the pipeline of previously ready buffers
+            for (int k = 0; k < nbuffers-1; k++)
+            {
+                bundle.compositor_release(bundle.compositor_acquire());
+                sleep_one_frame();
+            }
+
+            auto compositor = bundle.compositor_acquire();
+            ASSERT_EQ(last_client_id, compositor->id());
+            bundle.compositor_release(compositor);
+        }
+    }
+}
+
+TEST_F(SwitchingBundleTest, out_of_order_client_release)
+{
+    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto client1 = bundle.client_acquire();
+        auto client2 = bundle.client_acquire();
+        EXPECT_THROW(
+            bundle.client_release(client2),
+            std::logic_error
+        );
+
+        bundle.client_release(client1);
+        EXPECT_THROW(
+            bundle.client_release(client1),
+            std::logic_error
+        );
+    }
 }
 
 TEST_F(SwitchingBundleTest, compositor_acquire_basic)
 {
-    using namespace testing;
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-
-    EXPECT_CALL(*mock_default_swapper, compositor_acquire())
-        .Times(1)
-        .WillOnce(Return(stub_buffer));
-    EXPECT_CALL(*mock_default_swapper, compositor_release(stub_buffer))
-        .Times(1);
-
-    auto buffer = switcher.compositor_acquire();
-    switcher.compositor_release(buffer); 
-}
-
-TEST_F(SwitchingBundleTest, compositor_acquire_with_switch)
-{
-    using namespace testing;
-
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-
-    EXPECT_CALL(*mock_default_swapper, compositor_acquire())
-        .Times(1)
-        .WillOnce(Return(stub_buffer));
-    EXPECT_CALL(*mock_secondary_swapper, compositor_release(stub_buffer))
-        .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,_))
-        .Times(1)
-        .WillOnce(Return(mock_secondary_swapper));
-
-    auto buffer = switcher.compositor_acquire();
-
-    switcher.allow_framedropping(true);
- 
-    switcher.compositor_release(buffer); 
-}
-
-TEST_F(SwitchingBundleTest, switch_sequence)
-{
-    using namespace testing;
-    mc::SwitchingBundle switcher(mock_swapper_factory, properties);
-
-    InSequence seq;
-    EXPECT_CALL(*mock_default_swapper, force_client_abort())
-        .Times(1);
-    EXPECT_CALL(*mock_default_swapper, end_responsibility(_,_))
-        .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,mc::SwapperType::framedropping))
-        .Times(1)
-        .WillOnce(Return(mock_secondary_swapper));
-
-    switcher.allow_framedropping(true);
-}
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto client = bundle.client_acquire();
+        auto client_id = client->id();
+        bundle.client_release(client);
+
+        for (int monitor = 0; monitor < 10; monitor++)
+        {
+            auto compositor = bundle.compositor_acquire();
+            ASSERT_EQ(client_id, compositor->id());
+            bundle.compositor_release(compositor);
+        }
+    }
+}
+
+TEST_F(SwitchingBundleTest, compositor_acquire_never_blocks)
+{
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        const int N = 100;
+
+        bundle.force_requests_to_complete();
+
+        std::shared_ptr<mg::Buffer> buf[N];
+        for (int i = 0; i < N; i++)
+            buf[i] = bundle.compositor_acquire();
+
+        for (int i = 0; i < N; i++)
+            bundle.compositor_release(buf[i]);
+    }
+}
+
+TEST_F(SwitchingBundleTest, compositor_acquire_recycles_latest_ready_buffer)
+{
+    for (int nbuffers = 1; nbuffers < 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        mg::BufferID client_id;
+
+        for (int i = 0; i < 50; i++)
+        {
+            if (i % 10 == 0)
+            {
+                auto client = bundle.client_acquire();
+                client_id = client->id();
+                bundle.client_release(client);
+            }
+
+            for (int monitor_id = 0; monitor_id < 10; monitor_id++)
+            {
+                auto compositor = bundle.compositor_acquire();
+                ASSERT_EQ(client_id, compositor->id());
+                bundle.compositor_release(compositor);
+            }
+
+            sleep_one_frame();
+        }
+    }
+}
+
+TEST_F(SwitchingBundleTest, compositor_release_verifies_parameter)
+{
+    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto client = bundle.client_acquire();
+
+        EXPECT_THROW(
+            bundle.compositor_release(client),
+            std::logic_error
+        );
+        bundle.client_release(client);
+
+        auto compositor1 = bundle.compositor_acquire();
+        bundle.compositor_release(compositor1);
+        EXPECT_THROW(
+            bundle.compositor_release(compositor1),
+            std::logic_error
+        );
+    }
+}
+
+TEST_F(SwitchingBundleTest, overlapping_compositors_get_different_frames)
+{
+    // This test simulates bypass behaviour
+    for (int nbuffers = 2; nbuffers < 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        std::shared_ptr<mg::Buffer> compositor[2];
+
+        bundle.client_release(bundle.client_acquire());
+        compositor[0] = bundle.compositor_acquire();
+
+        sleep_one_frame();
+        bundle.client_release(bundle.client_acquire());
+        compositor[1] = bundle.compositor_acquire();
+
+        for (int i = 0; i < 50; i++)
+        {
+            // Two compositors acquired, and they're always different...
+            ASSERT_NE(compositor[0]->id(), compositor[1]->id());
+
+            // One of the compositors (the oldest one) gets a new buffer...
+            int oldest = i & 1;
+            bundle.compositor_release(compositor[oldest]);
+            bundle.client_release(bundle.client_acquire());
+            sleep_one_frame();
+            compositor[oldest] = bundle.compositor_acquire();
+        }
+
+        bundle.compositor_release(compositor[0]);
+        bundle.compositor_release(compositor[1]);
+    }
+}
+
+TEST_F(SwitchingBundleTest, snapshot_acquire_basic)
+{
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto compositor = bundle.compositor_acquire();
+        auto snapshot = bundle.snapshot_acquire();
+        EXPECT_EQ(snapshot->id(), compositor->id());
+        bundle.compositor_release(compositor);
+        bundle.snapshot_release(snapshot);
+    }
+}
+
+TEST_F(SwitchingBundleTest, snapshot_acquire_never_blocks)
+{
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        const int N = 100;
+
+        std::shared_ptr<mg::Buffer> buf[N];
+        for (int i = 0; i < N; i++)
+            buf[i] = bundle.snapshot_acquire();
+
+        for (int i = 0; i < N; i++)
+            bundle.snapshot_release(buf[i]);
+    }
+}
+
+TEST_F(SwitchingBundleTest, snapshot_release_verifies_parameter)
+{
+    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        auto compositor = bundle.compositor_acquire();
+
+        EXPECT_THROW(
+            bundle.snapshot_release(compositor),
+            std::logic_error
+        );
+
+        auto client = bundle.client_acquire();
+        auto snapshot = bundle.snapshot_acquire();
+
+        EXPECT_EQ(compositor->id(), snapshot->id());
+
+        EXPECT_NE(client->id(), snapshot->id());
+
+        EXPECT_THROW(
+            bundle.snapshot_release(client),
+            std::logic_error
+        );
+
+        bundle.snapshot_release(snapshot);
+
+        EXPECT_THROW(
+            bundle.snapshot_release(snapshot),
+            std::logic_error
+        );
+    }
+}
+
+namespace
+{
+    void compositor_thread(mc::SwitchingBundle &bundle,
+                           std::atomic<bool> &done)
+    {
+        while (!done)
+        {
+            bundle.compositor_release(bundle.compositor_acquire());
+            std::this_thread::yield();
+        }
+    }
+
+    void snapshot_thread(mc::SwitchingBundle &bundle,
+                           std::atomic<bool> &done)
+    {
+        while (!done)
+        {
+            bundle.snapshot_release(bundle.snapshot_acquire());
+            std::this_thread::yield();
+        }
+    }
+
+    void client_thread(mc::SwitchingBundle &bundle, int nframes)
+    {
+        for (int i = 0; i < nframes; i++)
+        {
+            bundle.client_release(bundle.client_acquire());
+            std::this_thread::yield();
+        }
+    }
+
+    void switching_client_thread(mc::SwitchingBundle &bundle, int nframes)
+    {
+        for (int i = 0; i < nframes; i += 10)
+        {
+            bundle.allow_framedropping(false);
+            for (int j = 0; j < 5; j++)
+                bundle.client_release(bundle.client_acquire());
+            std::this_thread::yield();
+
+            bundle.allow_framedropping(true);
+            for (int j = 0; j < 5; j++)
+                bundle.client_release(bundle.client_acquire());
+            std::this_thread::yield();
+        }
+    }
+}
+
+TEST_F(SwitchingBundleTest, stress)
+{
+    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
+    {
+        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+
+        std::atomic<bool> done;
+        done = false;
+
+        std::thread compositor(compositor_thread,
+                               std::ref(bundle),
+                               std::ref(done));
+        std::thread snapshotter1(snapshot_thread,
+                                std::ref(bundle),
+                                std::ref(done));
+        std::thread snapshotter2(snapshot_thread,
+                                std::ref(bundle),
+                                std::ref(done));
+
+        bundle.allow_framedropping(false);
+        std::thread client1(client_thread, std::ref(bundle), 1000);
+        client1.join();
+
+        bundle.allow_framedropping(true);
+        std::thread client2(client_thread, std::ref(bundle), 1000);
+        client2.join();
+
+        std::thread client3(switching_client_thread, std::ref(bundle), 1000);
+        client3.join();
+
+        done = true;
+
+        compositor.join();
+        snapshotter1.join();
+        snapshotter2.join();
+    }
+}
+
+#if 0  // FIXME (enabling this optimization breaks timing tests)
+TEST_F(SwitchingBundleTest, synchronous_clients_only_get_two_real_buffers)
+{
+    /*
+     * You might ask for more buffers, but we should only allocate two
+     * unique ones while it makes sense to do so. Buffers are big things and
+     * should be allocated sparingly...
+     */
+    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)