Merge lp:~kdub/mir/n10-support into lp:mir

[Kevin DuBois]

graphics: android:
1) change hwc1.1 to make use of sync fences during the compositor's gl renderloop. Note that we no longer wait for the render to complete, we pass this responsibility to the driver and the kernel.

2) support nexus 10

graphics: android:
1) change hwc1.1 to make use of sync fences during the compositor's gl renderloop. Note that we no longer wait for the render to complete, we pass this responsibility to the driver and the kernel.

2) support nexus 10

The big change in this review is the management of the android framebuffers state tracking. Previously, we simply had the framebuffers be owned in the dubiously-named FBSimpleSwapper, which was owned by the EGLNativeWindowType. This caused some problems because we had the native window, the state tracker and the display poster all having to keep track of the buffer state.

Furthermore, buffer fences are passed from the GL driver right to the HWC, and then from the HWC right to the GL driver. We never have to wait in mir for the GL fences in the composition/post new frame loop. This lets the mir better parallelize the gpu and cpu without waiting as much.

The astute reviewer might note that mga::DisplayDevice has become quite a strange... All the implementations of mga::DisplayDevice take a mga::FramebufferBundle and simply passthrough the functions. I made note of this in line 199. My plan is to remove the four noted functions from mga::DisplayDevice at the same that I address the strange mga::DisplayBufferFactory class. After addressing all that, the mga::DisplayBuffer will own a mga::FramebuffeBundle, which it will use to manage the framebuffers, and it will also have a mga::DisplayDevice class that is solely in change of posting a buffer and turning on/off the display. (no more buffer tracking in DisplayDevice)

NB: i still haven't gotten the unity-mir stack tested on top of these changes on both the nexus 4 and nexus 10. The basic test programs look good though. Please don't land until we can get unity tested.

NB: this will let us drop the patches to hwc on the nexus 4 (that codepath is no longer hit)

[Alan Griffiths (alan-griffiths)]

I don't understand all the detail but I'm happy with what I do follow.

review: Approve

[Alexandros Frantzis (afrantzis)]

> I don't understand all the detail but I'm happy with what I do follow.

Likewise.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1245
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/368/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/172
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/169
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/97
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/97/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/97
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/97/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-team-mir-development-branch-ci/368/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

It's hard to judge the GL performance improvement as we're limited to vsync on Android. But confirmed software framerates are improved dramatically by this proposal. Bug 1252173 fixed!

I expect GL will benefit similarly.

review: Approve (manual testing)

=== modified file 'include/shared/mir/graphics/android/mir_native_window.h'
--- include/shared/mir/graphics/android/mir_native_window.h	2013-10-28 16:35:51 +0000
+++ include/shared/mir/graphics/android/mir_native_window.h	2013-11-14 23:10:20 +0000
@@ -39,6 +39,7 @@
     int query(int key, int* value) const;
     int perform(int key, va_list args );
     int dequeueBuffer(struct ANativeWindowBuffer** buffer, int* fence);
+    int dequeueBufferAndWait(struct ANativeWindowBuffer** buffer);
     int queueBuffer(struct ANativeWindowBuffer* buffer, int fence);
     int cancelBuffer(struct ANativeWindowBuffer* buffer, int fence);
     int setSwapInterval(int interval);

=== modified file 'include/test/mir_test_doubles/mock_display_device.h'
--- include/test/mir_test_doubles/mock_display_device.h	2013-10-25 16:39:50 +0000
+++ include/test/mir_test_doubles/mock_display_device.h	2013-11-14 23:10:20 +0000
@@ -34,8 +34,7 @@
     ~MockDisplayDevice() noexcept {}
     MOCK_CONST_METHOD0(display_size, geometry::Size());
     MOCK_CONST_METHOD0(display_format, geometry::PixelFormat());
-    MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
-    MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::graphics::Buffer> const&));
+    MOCK_METHOD0(buffer_for_render, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(sync_to_display, void(bool));
     MOCK_METHOD1(mode, void(MirPowerMode));
     MOCK_METHOD2(commit_frame, void(EGLDisplay, EGLSurface));

=== added file 'include/test/mir_test_doubles/mock_framebuffer_bundle.h'
--- include/test/mir_test_doubles/mock_framebuffer_bundle.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_framebuffer_bundle.h	2013-11-14 23:10:20 +0000
@@ -0,0 +1,50 @@
+/*
+ * 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_FRAMEBUFFER_BUNDLE_H_
+#define MIR_TEST_DOUBLES_MOCK_FRAMEBUFFER_BUNDLE_H_
+
+#include "src/server/graphics/android/framebuffer_bundle.h"
+#include "stub_buffer.h"
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockFBBundle : public graphics::android::FramebufferBundle
+{
+    MockFBBundle()
+    {
+        using namespace testing;
+        ON_CALL(*this, last_rendered_buffer())
+            .WillByDefault(Return(std::make_shared<StubBuffer>()));
+    }
+    MOCK_METHOD0(fb_format, geometry::PixelFormat());
+    MOCK_METHOD0(fb_size, geometry::Size());
+    MOCK_METHOD0(buffer_for_render, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD0(last_rendered_buffer, std::shared_ptr<graphics::Buffer>());
+};
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_MOCK_FRAMEBUFFER_BUNDLE_H_ */

=== modified file 'include/test/mir_test_doubles/mock_hwc_composer_device_1.h'
--- include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2013-11-08 23:29:35 +0000
+++ include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2013-11-14 23:10:20 +0000
@@ -64,19 +64,34 @@
         return 0;
     }
 
+    void hwc_set_return_fence(int fence)
+    {
+        fb_fence = fence; 
+    }
+
     int save_last_prepare_arguments(struct hwc_composer_device_1 *, size_t, hwc_display_contents_1_t** displays)
     {
         return save_args(&display0_prepare_content, displays);
     }
 
-    int save_last_set_arguments(struct hwc_composer_device_1 *, size_t, hwc_display_contents_1_t** displays)
+    int save_last_set_arguments(
+        struct hwc_composer_device_1 *, size_t, hwc_display_contents_1_t** displays)
     {
-        hwc_display_contents_1_t* display = *displays;
-        for(auto i = 0u; i < display->numHwLayers; i++)
+        hwc_display_contents_1_t* primary_display = *displays;
+        if (!primary_display)
+            return -1;
+
+        for(auto i = 0u; i < primary_display->numHwLayers; i++)
         {
-            set_layerlist.push_back(display->hwLayers[i]);
+            set_layerlist.push_back(primary_display->hwLayers[i]);
             set_layerlist.back().visibleRegionScreen = {0, nullptr};
         }
+
+        if (primary_display->hwLayers)
+        {
+            primary_display->hwLayers[1].releaseFenceFd = fb_fence;
+        }
+
         return save_args(&display0_set_content, displays);
     }
 
@@ -129,6 +144,7 @@
     hwc_display_contents_1_t display0_set_content;
     std::vector<hwc_layer_1> set_layerlist;
     hwc_display_contents_1_t display0_prepare_content;
+    int fb_fence;
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_display_device.h'
--- include/test/mir_test_doubles/stub_display_device.h	2013-10-25 16:39:50 +0000
+++ include/test/mir_test_doubles/stub_display_device.h	2013-11-14 23:10:20 +0000
@@ -43,11 +43,13 @@
 
     geometry::Size display_size() const { return sz; }
     geometry::PixelFormat display_format() const { return geometry::PixelFormat::abgr_8888; }
-    unsigned int number_of_framebuffers_available() const { return 0; }
-    void set_next_frontbuffer(std::shared_ptr<mir::graphics::Buffer> const&) {}
     void sync_to_display(bool) {}
     void mode(MirPowerMode) {}
     void commit_frame(EGLDisplay, EGLSurface) {}
+    std::shared_ptr<graphics::Buffer> buffer_for_render()
+    {
+        return nullptr;
+    }
 
 private:
     geometry::Size sz;

=== modified file 'src/server/graphics/android/CMakeLists.txt'
--- src/server/graphics/android/CMakeLists.txt	2013-11-07 01:34:35 +0000
+++ src/server/graphics/android/CMakeLists.txt	2013-11-14 23:10:20 +0000
@@ -22,7 +22,7 @@
   android_alloc_adaptor.cpp
   server_render_window.cpp
   resource_factory.cpp
-  fb_simple_swapper.cpp
+  framebuffers.cpp
   fb_device.cpp
   internal_client_window.cpp
   interpreter_cache.cpp

=== modified file 'src/server/graphics/android/android_buffer_allocator.cpp'
--- src/server/graphics/android/android_buffer_allocator.cpp	2013-10-15 08:53:10 +0000
+++ src/server/graphics/android/android_buffer_allocator.cpp	2013-11-14 23:10:20 +0000
@@ -77,7 +77,7 @@
     return alloc_buffer_platform(buffer_properties.size, buffer_properties.format, usage);
 }
 
-std::shared_ptr<mga::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer_platform(
+std::shared_ptr<mg::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer_platform(
     geom::Size sz, geom::PixelFormat pf, mga::BufferUsage use)
 {
     auto native_handle = alloc_device->alloc_buffer(sz, pf, use);

=== modified file 'src/server/graphics/android/android_graphic_buffer_allocator.h'
--- src/server/graphics/android/android_graphic_buffer_allocator.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/android_graphic_buffer_allocator.h	2013-11-14 23:10:20 +0000
@@ -48,7 +48,7 @@
     std::shared_ptr<graphics::Buffer> alloc_buffer(
         graphics::BufferProperties const& buffer_properties);
 
-    std::shared_ptr<Buffer> alloc_buffer_platform(
+    std::shared_ptr<graphics::Buffer> alloc_buffer_platform(
         geometry::Size sz, geometry::PixelFormat pf, BufferUsage use);
 
     std::vector<geometry::PixelFormat> supported_pixel_formats();

=== modified file 'src/server/graphics/android/display_device.h'
--- src/server/graphics/android/display_device.h	2013-10-25 16:39:50 +0000
+++ src/server/graphics/android/display_device.h	2013-11-14 23:10:20 +0000
@@ -40,12 +40,13 @@
 public:
     virtual ~DisplayDevice() = default;
 
+    //TODO: (kdub) these 4 functions should be removed from this interface. The classes currently using
+    //      these four functions will start to use mga::FramebufferBundle.
     virtual geometry::Size display_size() const = 0; 
     virtual geometry::PixelFormat display_format() const = 0; 
-    virtual unsigned int number_of_framebuffers_available() const = 0;
-
-    virtual void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
+    virtual std::shared_ptr<graphics::Buffer> buffer_for_render() = 0;
     virtual void sync_to_display(bool sync) = 0;
+
     virtual void mode(MirPowerMode mode) = 0;
     virtual void commit_frame(EGLDisplay dpy, EGLSurface sur) = 0;
 

=== modified file 'src/server/graphics/android/fb_device.cpp'
--- src/server/graphics/android/fb_device.cpp	2013-10-24 19:10:34 +0000
+++ src/server/graphics/android/fb_device.cpp	2013-11-14 23:10:20 +0000
@@ -21,6 +21,7 @@
 #include "mir/graphics/android/native_buffer.h"
 #include "android_format_conversion-inl.h"
 #include "fb_device.h"
+#include "framebuffer_bundle.h"
 #include "buffer.h"
 
 #include <boost/throw_exception.hpp>
@@ -30,8 +31,11 @@
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
-mga::FBDevice::FBDevice(std::shared_ptr<framebuffer_device_t> const& fbdev)
-    : fb_device(fbdev)
+mga::FBDevice::FBDevice(
+    std::shared_ptr<framebuffer_device_t> const& fbdev,
+    std::shared_ptr<FramebufferBundle> const& bundle)
+    : fb_device(fbdev),
+      fb_bundle(bundle)
 {
     if (fb_device->setSwapInterval)
     {
@@ -39,15 +43,8 @@
     }
 }
 
-void mga::FBDevice::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
+void mga::FBDevice::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const&)
 {
-    auto native_buffer = buffer->native_buffer_handle();
-    native_buffer->wait_for_content();
-
-    if (fb_device->post(fb_device.get(), native_buffer->handle()) != 0)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("error posting with fb device"));
-    }
 }
 
 geom::Size mga::FBDevice::display_size() const
@@ -60,10 +57,9 @@
     return to_mir_format(fb_device->format);
 }
 
-unsigned int mga::FBDevice::number_of_framebuffers_available() const
+std::shared_ptr<mg::Buffer> mga::FBDevice::buffer_for_render()
 {
-    auto fb_num = static_cast<unsigned int>(fb_device->numFramebuffers);
-    return std::max(2u, fb_num);
+    return fb_bundle->buffer_for_render();
 }
 
 void mga::FBDevice::sync_to_display(bool sync)
@@ -87,6 +83,15 @@
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("eglSwapBuffers failure\n"));
     }
+
+    auto buffer = fb_bundle->last_rendered_buffer();
+    auto native_buffer = buffer->native_buffer_handle();
+    native_buffer->wait_for_content();
+
+    if (fb_device->post(fb_device.get(), native_buffer->handle()) != 0)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("error posting with fb device"));
+    }
 }
 
 void mga::FBDevice::mode(MirPowerMode mode)

=== modified file 'src/server/graphics/android/fb_device.h'
--- src/server/graphics/android/fb_device.h	2013-10-25 16:39:50 +0000
+++ src/server/graphics/android/fb_device.h	2013-11-14 23:10:20 +0000
@@ -29,16 +29,19 @@
 {
 namespace android
 {
+class FramebufferBundle;
 
 class FBDevice : public DisplayDevice 
 {
 public:
-    FBDevice(std::shared_ptr<framebuffer_device_t> const&);
+    FBDevice(std::shared_ptr<framebuffer_device_t> const& fbdev,
+             std::shared_ptr<FramebufferBundle> const& bundle);
 
     geometry::Size display_size() const; 
     geometry::PixelFormat display_format() const; 
     unsigned int number_of_framebuffers_available() const;
 
+    std::shared_ptr<graphics::Buffer> buffer_for_render();
     void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer);
     void sync_to_display(bool sync); 
     void mode(MirPowerMode mode);
@@ -47,6 +50,7 @@
 
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;
+    std::shared_ptr<FramebufferBundle> const fb_bundle;
 };
 
 }

=== renamed file 'src/server/graphics/android/fb_swapper.h' => 'src/server/graphics/android/framebuffer_bundle.h'
--- src/server/graphics/android/fb_swapper.h	2013-10-15 08:53:10 +0000
+++ src/server/graphics/android/framebuffer_bundle.h	2013-11-14 23:10:20 +0000
@@ -17,9 +17,11 @@
  * Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_GRAPHICS_ANDROID_FB_SWAPPER_H_
-#define MIR_GRAPHICS_ANDROID_FB_SWAPPER_H_
+#ifndef MIR_GRAPHICS_ANDROID_FRAMEBUFFER_BUNDLE_H_
+#define MIR_GRAPHICS_ANDROID_FRAMEBUFFER_BUNDLE_H_
 
+#include "mir/geometry/pixel_format.h"
+#include "mir/geometry/size.h"
 #include <memory>
 
 namespace mir
@@ -31,20 +33,23 @@
 namespace android
 {
 
-class FBSwapper{
+class FramebufferBundle{
 public:
-    virtual ~FBSwapper() = default;
-
-    virtual std::shared_ptr<Buffer> compositor_acquire() = 0;
-    virtual void compositor_release(std::shared_ptr<Buffer> const& released_buffer) = 0;
+    virtual ~FramebufferBundle() = default;
+
+    virtual geometry::PixelFormat fb_format() = 0;
+    virtual geometry::Size fb_size() = 0;
+    virtual std::shared_ptr<Buffer> buffer_for_render() = 0;
+    virtual std::shared_ptr<Buffer> last_rendered_buffer() = 0;
+
 protected:
-    FBSwapper() = default;
-    FBSwapper(FBSwapper const&) = delete;
-    FBSwapper& operator=(FBSwapper const&) = delete;
+    FramebufferBundle() = default;
+    FramebufferBundle(FramebufferBundle const&) = delete;
+    FramebufferBundle& operator=(FramebufferBundle const&) = delete;
 };
 
 }
 }
 }
 
-#endif /* MIR_GRAPHICS_ANDROID_FB_SWAPPER_H_ */
+#endif /* MIR_GRAPHICS_ANDROID_FRAMEBUFFER_BUNDLE_H_ */

=== renamed file 'src/server/graphics/android/fb_simple_swapper.cpp' => 'src/server/graphics/android/framebuffers.cpp'
--- src/server/graphics/android/fb_simple_swapper.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/framebuffers.cpp	2013-11-14 23:10:20 +0000
@@ -17,31 +17,137 @@
  * Kevin DuBois <[e-mail]>
  */
 
-#include "fb_simple_swapper.h"
+#include "framebuffers.h"
+#include "android_format_conversion-inl.h"
+#include "graphic_buffer_allocator.h"
 
+#include <algorithm>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
-
-std::shared_ptr<mg::Buffer> mga::FBSimpleSwapper::compositor_acquire()
+namespace geom=mir::geometry;
+
+namespace
+{
+geom::PixelFormat determine_hwc11_fb_format()
+{
+    static EGLint const fb_egl_config_attr [] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
+        EGL_NONE
+    };
+
+    EGLConfig fb_egl_config;
+    int matching_configs;
+    EGLint major, minor;
+    auto egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    eglInitialize(egl_display, &major, &minor);
+    eglChooseConfig(egl_display, fb_egl_config_attr, &fb_egl_config, 1, &matching_configs);
+
+    geom::PixelFormat fb_format;
+    if (matching_configs)
+    {
+        int visual_id;
+        eglGetConfigAttrib(egl_display, fb_egl_config, EGL_NATIVE_VISUAL_ID, &visual_id);
+        fb_format = mga::to_mir_format(visual_id); 
+    }
+    else
+    {
+        //we couldn't figure out the fb format via egl. In this case, we
+        //assume abgr_8888. HWC api really should provide this information directly.
+        fb_format = geom::PixelFormat::abgr_8888;
+    }
+
+    eglTerminate(egl_display);
+    return fb_format;
+}
+
+geom::Size determine_hwc11_size(
+    std::shared_ptr<hwc_composer_device_1> const& hwc_device)
+{
+    size_t num_configs = 1;
+    uint32_t primary_display_config;
+    auto rc = hwc_device->getDisplayConfigs(hwc_device.get(), HWC_DISPLAY_PRIMARY, &primary_display_config, &num_configs);
+    if (rc != 0)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("could not determine hwc display config")); 
+    }
+    static uint32_t size_request[3] = { HWC_DISPLAY_WIDTH,
+                                        HWC_DISPLAY_HEIGHT,
+                                        HWC_DISPLAY_NO_ATTRIBUTE};
+
+    int size_values[2];
+    hwc_device->getDisplayAttributes(hwc_device.get(), HWC_DISPLAY_PRIMARY, primary_display_config,
+                                     size_request, size_values);
+
+    return {size_values[0], size_values[1]};
+}
+}
+
+mga::Framebuffers::Framebuffers(
+    std::shared_ptr<mga::GraphicBufferAllocator> const& buffer_allocator,
+    std::shared_ptr<hwc_composer_device_1> const& hwc)
+    : format(determine_hwc11_fb_format()),
+      size(determine_hwc11_size(hwc)) 
+{
+    for(auto i = 0u; i < 2; i++)
+    {
+        queue.push(buffer_allocator->alloc_buffer_platform(size, format, mga::BufferUsage::use_framebuffer_gles));
+    }
+}
+
+mga::Framebuffers::Framebuffers(
+    std::shared_ptr<mga::GraphicBufferAllocator> const& buffer_allocator,
+    std::shared_ptr<framebuffer_device_t> const& fb)
+    : format{mga::to_mir_format(fb->format)},
+      size({fb->width, fb->height}) 
+{
+    //guarantee always 2 fb's allocated
+    auto fb_num = static_cast<unsigned int>(fb->numFramebuffers);
+    fb_num = std::max(2u, fb_num);
+    for(auto i = 0u; i < fb_num; i++)
+    {
+        queue.push(buffer_allocator->alloc_buffer_platform(size, format, mga::BufferUsage::use_framebuffer_gles));
+    }
+}
+
+geom::PixelFormat mga::Framebuffers::fb_format()
+{
+    return format;
+}
+geom::Size mga::Framebuffers::fb_size()
+{
+    return size;
+}
+
+std::shared_ptr<mg::Buffer> mga::Framebuffers::buffer_for_render()
 {
     std::unique_lock<std::mutex> lk(queue_lock);
-    while (queue.empty())
+    while (buffer_being_rendered)
     {
         cv.wait(lk);
     }
 
-    auto buffer = queue.front();
+    buffer_being_rendered = queue.front();
     queue.pop();
-    return buffer;
+    return std::shared_ptr<mg::Buffer>(buffer_being_rendered.get(),
+        [this](mg::Buffer*)
+        {
+            std::unique_lock<std::mutex> lk(queue_lock);
+            queue.push(buffer_being_rendered);
+            buffer_being_rendered.reset();
+            cv.notify_all();
+        });
 }
 
-void mga::FBSimpleSwapper::compositor_release(std::shared_ptr<mg::Buffer> const& released_buffer)
+std::shared_ptr<mg::Buffer> mga::Framebuffers::last_rendered_buffer()
 {
     std::unique_lock<std::mutex> lk(queue_lock);
-
-    queue.push(released_buffer);
-    cv.notify_all();
+    return queue.back();
 }

=== renamed file 'src/server/graphics/android/fb_simple_swapper.h' => 'src/server/graphics/android/framebuffers.h'
--- src/server/graphics/android/fb_simple_swapper.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/framebuffers.h	2013-11-14 23:10:20 +0000
@@ -20,8 +20,11 @@
 #ifndef MIR_GRAPHICS_ANDROID_FB_SIMPLE_SWAPPER_H_
 #define MIR_GRAPHICS_ANDROID_FB_SIMPLE_SWAPPER_H_
 
-#include "fb_swapper.h"
+#include "framebuffer_bundle.h"
 
+#include <hardware/gralloc.h>
+#include <hardware/fb.h>
+#include <hardware/hwcomposer.h>
 #include <condition_variable>
 #include <queue>
 #include <vector>
@@ -33,26 +36,28 @@
 {
 namespace android
 {
+class GraphicBufferAllocator;
 
-class FBSimpleSwapper : public FBSwapper
+class Framebuffers : public FramebufferBundle
 {
 public:
-    template<typename BufferPtrContainer>
-    explicit FBSimpleSwapper(BufferPtrContainer const& buffer_list)
-    {
-        for (auto& buffer : buffer_list)
-        {
-            queue.push(buffer);
-        }
-    }
+    Framebuffers(std::shared_ptr<GraphicBufferAllocator> const& buffer_allocator,
+                 std::shared_ptr<hwc_composer_device_1> const& hwc);
+    Framebuffers(std::shared_ptr<GraphicBufferAllocator> const& buffer_allocator,
+                 std::shared_ptr<framebuffer_device_t> const& fb);
 
-    std::shared_ptr<Buffer> compositor_acquire();
-    void compositor_release(std::shared_ptr<Buffer> const& released_buffer);
+    geometry::PixelFormat fb_format();
+    geometry::Size fb_size();
+    std::shared_ptr<Buffer> buffer_for_render();
+    std::shared_ptr<Buffer> last_rendered_buffer();
 
 private:
+    geometry::PixelFormat const format;
+    geometry::Size const size;
+
     std::mutex queue_lock;
+    std::shared_ptr<Buffer> buffer_being_rendered;
     std::condition_variable cv;
-
     std::queue<std::shared_ptr<graphics::Buffer>> queue;
 };
 

=== modified file 'src/server/graphics/android/graphic_buffer_allocator.h'
--- src/server/graphics/android/graphic_buffer_allocator.h	2013-05-24 15:44:11 +0000
+++ src/server/graphics/android/graphic_buffer_allocator.h	2013-11-14 23:10:20 +0000
@@ -38,7 +38,7 @@
 class GraphicBufferAllocator
 {
 public:
-    virtual std::shared_ptr<Buffer> alloc_buffer_platform(
+    virtual std::shared_ptr<graphics::Buffer> alloc_buffer_platform(
         geometry::Size sz, geometry::PixelFormat pf, BufferUsage use) = 0;
 
 protected:

=== modified file 'src/server/graphics/android/hwc10_device.cpp'
--- src/server/graphics/android/hwc10_device.cpp	2013-11-12 23:49:22 +0000
+++ src/server/graphics/android/hwc10_device.cpp	2013-11-14 23:10:20 +0000
@@ -19,6 +19,7 @@
 
 #include "hwc10_device.h"
 #include "hwc_vsync_coordinator.h"
+#include "framebuffer_bundle.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -27,19 +28,17 @@
 namespace mga = mir::graphics::android;
 namespace geom = mir::geometry;
 mga::HWC10Device::HWC10Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                              std::shared_ptr<FramebufferBundle> const& fb_bundle,
                               std::shared_ptr<DisplayDevice> const& fbdev,
                               std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : HWCCommonDevice(hwc_device, coordinator),
+      fb_bundle(fb_bundle),
       layer_list({mga::CompositionLayer{HWC_SKIP_LAYER}}),
       fb_device(fbdev),
       wait_for_vsync(true)
 {
 }
 
-mga::HWC10Device::~HWC10Device() noexcept
-{
-}
-
 geom::Size mga::HWC10Device::display_size() const
 {
     return fb_device->display_size();
@@ -50,14 +49,9 @@
     return fb_device->display_format();
 }
 
-unsigned int mga::HWC10Device::number_of_framebuffers_available() const
-{
-    return fb_device->number_of_framebuffers_available();
-}
-
-void mga::HWC10Device::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    fb_device->set_next_frontbuffer(buffer);
+std::shared_ptr<mg::Buffer> mga::HWC10Device::buffer_for_render()
+{
+    return fb_bundle->buffer_for_render();
 }
 
 void mga::HWC10Device::commit_frame(EGLDisplay dpy, EGLSurface sur)

=== modified file 'src/server/graphics/android/hwc10_device.h'
--- src/server/graphics/android/hwc10_device.h	2013-11-07 23:22:19 +0000
+++ src/server/graphics/android/hwc10_device.h	2013-11-14 23:10:20 +0000
@@ -28,23 +28,25 @@
 namespace android
 {
 class DisplayDevice;
+class FramebufferBundle;
 
 class HWC10Device : public HWCCommonDevice
 {
 public:
     HWC10Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                std::shared_ptr<FramebufferBundle> const& fb_bundle,
                 std::shared_ptr<DisplayDevice> const& fbdev,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
-    ~HWC10Device() noexcept;
 
     geometry::Size display_size() const; 
-    geometry::PixelFormat display_format() const; 
-    unsigned int number_of_framebuffers_available() const;
-    void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer);
+    geometry::PixelFormat display_format() const;
+
+    std::shared_ptr<graphics::Buffer> buffer_for_render();
     void sync_to_display(bool sync); 
     void commit_frame(EGLDisplay dpy, EGLSurface sur);
 
 private:
+    std::shared_ptr<FramebufferBundle> const fb_bundle;
     LayerList layer_list;
 
     std::shared_ptr<DisplayDevice> const fb_device;

=== modified file 'src/server/graphics/android/hwc11_device.cpp'
--- src/server/graphics/android/hwc11_device.cpp	2013-11-14 03:27:06 +0000
+++ src/server/graphics/android/hwc11_device.cpp	2013-11-14 23:10:20 +0000
@@ -20,7 +20,8 @@
 #include "hwc11_device.h"
 #include "hwc_layerlist.h"
 #include "hwc_vsync_coordinator.h"
-#include "android_format_conversion-inl.h"
+#include "framebuffer_bundle.h"
+#include "buffer.h"
 #include "mir/graphics/android/sync_fence.h"
 #include "mir/graphics/android/native_buffer.h"
 #include "mir/graphics/buffer.h"
@@ -33,94 +34,29 @@
 namespace mga=mir::graphics::android;
 namespace geom = mir::geometry;
 
-namespace
-{
-geom::PixelFormat determine_fb_format()
-{
-    static EGLint const fb_egl_config_attr [] =
-    {
-        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
-        EGL_NONE
-    };
-
-    EGLConfig fb_egl_config;
-    int matching_configs;
-    EGLint major, minor;
-    auto egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    eglInitialize(egl_display, &major, &minor);
-    eglChooseConfig(egl_display, fb_egl_config_attr, &fb_egl_config, 1, &matching_configs);
-
-    geom::PixelFormat fb_format;
-    if (matching_configs)
-    {
-        int visual_id;
-        eglGetConfigAttrib(egl_display, fb_egl_config, EGL_NATIVE_VISUAL_ID, &visual_id);
-        fb_format = mga::to_mir_format(visual_id); 
-    }
-    else
-    {
-        //we couldn't figure out the fb format via egl. In this case, we
-        //assume abgr_8888. HWC api really should provide this information directly.
-        fb_format = geom::PixelFormat::abgr_8888;
-    }
-
-    eglTerminate(egl_display);
-    return fb_format;
-}
-}
-
 mga::HWC11Device::HWC11Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                              std::shared_ptr<FramebufferBundle> const& fb_bundle,
                               std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : HWCCommonDevice(hwc_device, coordinator),
-      layer_list({mga::FramebufferLayer{}}),
-      sync_ops(std::make_shared<mga::RealSyncFileOps>()),
-      fb_format(determine_fb_format())
-{
-    size_t num_configs = 1;
-    auto rc = hwc_device->getDisplayConfigs(hwc_device.get(), HWC_DISPLAY_PRIMARY, &primary_display_config, &num_configs);
-    if (rc != 0)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("could not determine hwc display config")); 
-    }
-}
-
-mga::HWC11Device::~HWC11Device() noexcept
+      fb_bundle(fb_bundle),
+      layer_list({mga::CompositionLayer{true}, mga::FramebufferLayer{}}),
+      sync_ops(std::make_shared<mga::RealSyncFileOps>())
 {
 }
 
 geom::Size mga::HWC11Device::display_size() const
 {
-    static uint32_t size_request[3] = { HWC_DISPLAY_WIDTH,
-                                        HWC_DISPLAY_HEIGHT,
-                                        HWC_DISPLAY_NO_ATTRIBUTE};
-
-    int size_values[2];
-    hwc_device->getDisplayAttributes(hwc_device.get(), HWC_DISPLAY_PRIMARY, primary_display_config,
-                                     size_request, size_values);
-
-    return {size_values[0], size_values[1]};
+    return fb_bundle->fb_size();
 }
 
 geom::PixelFormat mga::HWC11Device::display_format() const
 {
-    return fb_format;
-}
-
-unsigned int mga::HWC11Device::number_of_framebuffers_available() const
-{
-    //note: the default for hwc devices is 2 framebuffers. However, the hwcomposer api allows for the module to give
-    //us a hint to triple buffer. Taking this hint is currently not supported.
-    return 2u;
-}
-
-void mga::HWC11Device::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
-{
-    layer_list.set_fb_target(buffer->native_buffer_handle());
-    //TODO: wait for framebuffer render to complete here. Eventually, we want to pass the fence right
-    //      into hwc_device->set() and let that wait for the render to complete.
-    buffer->native_buffer_handle()->wait_for_content();
+    return fb_bundle->fb_format();
+}
+
+std::shared_ptr<mg::Buffer> mga::HWC11Device::buffer_for_render()
+{
+    return fb_bundle->buffer_for_render();
 }
 
 void mga::HWC11Device::commit_frame(EGLDisplay dpy, EGLSurface sur)
@@ -136,19 +72,29 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc prepare()"));
     }
 
-    /* note, swapbuffers will go around through the driver and call
-       set_next_frontbuffer, updating the fb in layerlist before committing */
     if (eglSwapBuffers(dpy, sur) == EGL_FALSE)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error during eglSwapBuffers"));
     }
 
+    /* update gles rendered surface */
+    auto buffer = fb_bundle->last_rendered_buffer();
+    auto native_buffer = buffer->native_buffer_handle();
+    layer_list.set_fb_target(native_buffer);
+
     if (hwc_device->set(hwc_device.get(), 1, displays))
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc set()"));
     }
-    mga::SyncFence fence(sync_ops, displays[HWC_DISPLAY_PRIMARY]->retireFenceFd);
-    fence.wait();
+
+    if (last_display_fence)
+        last_display_fence->wait();
+
+    int framebuffer_fence = layer_list.framebuffer_fence();
+    native_buffer->update_fence(framebuffer_fence);
+
+    last_display_fence = std::make_shared<mga::SyncFence>(
+        sync_ops, displays[HWC_DISPLAY_PRIMARY]->retireFenceFd);
 }
 
 void mga::HWC11Device::sync_to_display(bool)

=== modified file 'src/server/graphics/android/hwc11_device.h'
--- src/server/graphics/android/hwc11_device.h	2013-11-08 18:25:19 +0000
+++ src/server/graphics/android/hwc11_device.h	2013-11-14 23:10:20 +0000
@@ -32,25 +32,28 @@
 {
 class HWCVsyncCoordinator;
 class SyncFileOps;
+class SyncFence;
+class FramebufferBundle;
 
 class HWC11Device : public HWCCommonDevice
 {
 public:
     HWC11Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                std::shared_ptr<FramebufferBundle> const& fb_bundle,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
-    ~HWC11Device() noexcept;
 
     geometry::Size display_size() const; 
     geometry::PixelFormat display_format() const; 
-    unsigned int number_of_framebuffers_available() const;
-    void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer);
-    void sync_to_display(bool sync);
- 
+
+    std::shared_ptr<graphics::Buffer> buffer_for_render();
+    void sync_to_display(bool sync); 
     void commit_frame(EGLDisplay dpy, EGLSurface sur);
 
 private:
+    std::shared_ptr<FramebufferBundle> const fb_bundle;
     LayerList layer_list;
 
+    std::shared_ptr<SyncFence> last_display_fence;
     std::shared_ptr<SyncFileOps> const sync_ops;
     unsigned int primary_display_config;
     geometry::PixelFormat fb_format;

=== modified file 'src/server/graphics/android/hwc_layerlist.cpp'
--- src/server/graphics/android/hwc_layerlist.cpp	2013-11-11 21:34:15 +0000
+++ src/server/graphics/android/hwc_layerlist.cpp	2013-11-14 23:10:20 +0000
@@ -108,12 +108,20 @@
 void mga::LayerList::set_fb_target(std::shared_ptr<NativeBuffer> const& native_buffer)
 {
     auto fb_position = hwc_representation->numHwLayers - 1;
+
     if (hwc_representation->hwLayers[fb_position].compositionType == HWC_FRAMEBUFFER_TARGET)
     {
         hwc_representation->hwLayers[fb_position] = mga::FramebufferLayer(*native_buffer);
+        hwc_representation->hwLayers[fb_position].acquireFenceFd = native_buffer->copy_fence();
     }
 }
 
+mga::NativeFence mga::LayerList::framebuffer_fence()
+{
+    auto fb_position = hwc_representation->numHwLayers - 1;
+    return hwc_representation->hwLayers[fb_position].releaseFenceFd; 
+}
+
 hwc_display_contents_1_t* mga::LayerList::native_list() const
 {
     return hwc_representation.get();

=== modified file 'src/server/graphics/android/hwc_layerlist.h'
--- src/server/graphics/android/hwc_layerlist.h	2013-11-11 21:34:15 +0000
+++ src/server/graphics/android/hwc_layerlist.h	2013-11-14 23:10:20 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_GRAPHICS_ANDROID_HWC_LAYERLIST_H_
 #define MIR_GRAPHICS_ANDROID_HWC_LAYERLIST_H_
 
+#include "mir/graphics/android/fence.h"
 #include "mir/geometry/rectangle.h"
 #include <hardware/hwcomposer.h>
 #include <memory>
@@ -67,7 +68,9 @@
     LayerList(std::initializer_list<HWCLayer> const& layers);
 
     hwc_display_contents_1_t* native_list() const;
+
     void set_fb_target(std::shared_ptr<NativeBuffer> const&);
+    NativeFence framebuffer_fence();
 
 private:
     std::shared_ptr<hwc_display_contents_1_t> hwc_representation;

=== modified file 'src/server/graphics/android/resource_factory.cpp'
--- src/server/graphics/android/resource_factory.cpp	2013-11-14 03:27:06 +0000
+++ src/server/graphics/android/resource_factory.cpp	2013-11-14 23:10:20 +0000
@@ -21,7 +21,7 @@
 #include "buffer.h"
 #include "resource_factory.h"
 #include "fb_device.h"
-#include "fb_simple_swapper.h"
+#include "framebuffers.h"
 #include "graphic_buffer_allocator.h"
 #include "server_render_window.h"
 #include "interpreter_cache.h"
@@ -83,31 +83,24 @@
 std::shared_ptr<ANativeWindow> mga::ResourceFactory::create_native_window(
     std::shared_ptr<mga::DisplayDevice> const& device) const
 {
-    auto size = device->display_size();
-    auto pf = device->display_format();
-    auto num_framebuffers = device->number_of_framebuffers_available();
-    std::vector<std::shared_ptr<mg::Buffer>> buffers;
-    for (auto i = 0u; i < num_framebuffers; ++i)
-    {
-        buffers.push_back(buffer_allocator->alloc_buffer_platform(size, pf, mga::BufferUsage::use_framebuffer_gles));
-    }
-    auto swapper = std::make_shared<mga::FBSimpleSwapper>(buffers);
     auto cache = std::make_shared<mga::InterpreterCache>();
-    auto interpreter = std::make_shared<ServerRenderWindow>(swapper, device, cache);
+    auto interpreter = std::make_shared<ServerRenderWindow>(device, cache);
     return std::make_shared<MirNativeWindow>(interpreter); 
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_fb_device(
     std::shared_ptr<framebuffer_device_t> const& fb_native_device) const
 {
-    return std::make_shared<mga::FBDevice>(fb_native_device);
+    auto framebuffers = std::make_shared<mga::Framebuffers>(buffer_allocator, fb_native_device);
+    return std::make_shared<mga::FBDevice>(fb_native_device, framebuffers);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc11_device(
     std::shared_ptr<hwc_composer_device_1> const& hwc_native_device) const
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
-    return std::make_shared<mga::HWC11Device>(hwc_native_device, syncer);
+    auto framebuffers = std::make_shared<mga::Framebuffers>(buffer_allocator, hwc_native_device);
+    return std::make_shared<mga::HWC11Device>(hwc_native_device, framebuffers, syncer);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc10_device(
@@ -116,5 +109,6 @@
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto fb_device = create_fb_device(fb_native_device);
-    return std::make_shared<mga::HWC10Device>(hwc_native_device, fb_device, syncer);
+    auto framebuffers = std::make_shared<mga::Framebuffers>(buffer_allocator, fb_native_device);
+    return std::make_shared<mga::HWC10Device>(hwc_native_device, framebuffers, fb_device, syncer);
 }

=== modified file 'src/server/graphics/android/server_render_window.cpp'
--- src/server/graphics/android/server_render_window.cpp	2013-10-25 16:39:50 +0000
+++ src/server/graphics/android/server_render_window.cpp	2013-11-14 23:10:20 +0000
@@ -21,7 +21,6 @@
 #include "mir/graphics/android/sync_fence.h"
 #include "server_render_window.h"
 #include "display_device.h"
-#include "fb_swapper.h"
 #include "buffer.h"
 #include "android_format_conversion-inl.h"
 #include "interpreter_resource_cache.h"
@@ -34,11 +33,10 @@
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
-mga::ServerRenderWindow::ServerRenderWindow(std::shared_ptr<mga::FBSwapper> const& swapper,
-                                            std::shared_ptr<mga::DisplayDevice> const& display_poster,
-                                            std::shared_ptr<InterpreterResourceCache> const& cache)
-    : swapper(swapper),
-      poster(display_poster),
+mga::ServerRenderWindow::ServerRenderWindow(
+    std::shared_ptr<mga::DisplayDevice> const& display_poster,
+    std::shared_ptr<InterpreterResourceCache> const& cache)
+    : poster(display_poster),
       resource_cache(cache),
       format(mga::to_android_format(poster->display_format()))
 {
@@ -46,7 +44,7 @@
 
 mg::NativeBuffer* mga::ServerRenderWindow::driver_requests_buffer()
 {
-    auto buffer = swapper->compositor_acquire();
+    auto buffer = poster->buffer_for_render();
     auto handle = buffer->native_buffer_handle();
     resource_cache->store_buffer(buffer, handle);
     return handle.get();
@@ -55,9 +53,7 @@
 void mga::ServerRenderWindow::driver_returns_buffer(ANativeWindowBuffer* buffer, int fence_fd)
 {
     resource_cache->update_native_fence(buffer, fence_fd);
-    auto buffer_resource = resource_cache->retrieve_buffer(buffer);
-    poster->set_next_frontbuffer(buffer_resource);
-    swapper->compositor_release(buffer_resource);
+    resource_cache->retrieve_buffer(buffer);
 }
 
 void mga::ServerRenderWindow::dispatch_driver_request_format(int request_format)

=== modified file 'src/server/graphics/android/server_render_window.h'
--- src/server/graphics/android/server_render_window.h	2013-10-25 16:39:50 +0000
+++ src/server/graphics/android/server_render_window.h	2013-11-14 23:10:20 +0000
@@ -32,14 +32,12 @@
 namespace android
 {
 
-class FBSwapper;
 class DisplayDevice;
 class InterpreterResourceCache;
 class ServerRenderWindow : public AndroidDriverInterpreter 
 {
 public:
-    ServerRenderWindow(std::shared_ptr<FBSwapper> const& swapper,
-                       std::shared_ptr<DisplayDevice> const& display_poster,
+    ServerRenderWindow(std::shared_ptr<DisplayDevice> const& display_poster,
                        std::shared_ptr<InterpreterResourceCache> const&);
 
     graphics::NativeBuffer* driver_requests_buffer();
@@ -49,7 +47,6 @@
     void sync_to_display(bool sync);
 
 private:
-    std::shared_ptr<FBSwapper> const swapper;
     std::shared_ptr<DisplayDevice> const poster;
     std::shared_ptr<InterpreterResourceCache> const resource_cache;
 

=== modified file 'src/shared/graphics/android/mir_native_window.cpp'
--- src/shared/graphics/android/mir_native_window.cpp	2013-10-28 16:35:51 +0000
+++ src/shared/graphics/android/mir_native_window.cpp	2013-11-14 23:10:20 +0000
@@ -69,10 +69,8 @@
 int dequeueBuffer_deprecated_static (struct ANativeWindow* window,
                           struct ANativeWindowBuffer** buffer)
 {
-    int fence_fd = -1;
     auto self = static_cast<mga::MirNativeWindow*>(window);
-    //todo: we have to close the fence
-    return self->dequeueBuffer(buffer, &fence_fd);
+    return self->dequeueBufferAndWait(buffer);
 }
 
 int dequeueBuffer_static (struct ANativeWindow* window,
@@ -169,6 +167,14 @@
     return 0;
 }
 
+int mga::MirNativeWindow::dequeueBufferAndWait(struct ANativeWindowBuffer** buffer_to_driver)
+{
+    auto buffer = driver_interpreter->driver_requests_buffer();
+    *buffer_to_driver = buffer->anwb();
+    buffer->wait_for_content();
+    return 0;
+}
+
 int mga::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer, int fence)
 {
     driver_interpreter->driver_returns_buffer(buffer, fence);

=== modified file 'tests/integration-tests/client/test_client_render.cpp'
--- tests/integration-tests/client/test_client_render.cpp	2013-11-13 09:22:11 +0000
+++ tests/integration-tests/client/test_client_render.cpp	2013-11-14 23:10:20 +0000
@@ -274,13 +274,13 @@
         return 0xFF00FF00;
     }
 
-    std::shared_ptr<mga::Buffer> second_to_last_posted_buffer()
+    std::shared_ptr<mg::Buffer> second_to_last_posted_buffer()
     {
         std::unique_lock<std::mutex> lk(buffer_mutex);
         return client_buffer;
     }
 
-    std::shared_ptr<mga::Buffer> last_posted_buffer()
+    std::shared_ptr<mg::Buffer> last_posted_buffer()
     {
         std::unique_lock<std::mutex> lk(buffer_mutex);
         return last_posted;
@@ -288,8 +288,8 @@
 
 private:
     std::shared_ptr<mga::AndroidGraphicBufferAllocator> allocator;
-    std::shared_ptr<mga::Buffer> client_buffer;
-    std::shared_ptr<mga::Buffer> last_posted;
+    std::shared_ptr<mg::Buffer> client_buffer;
+    std::shared_ptr<mg::Buffer> last_posted;
     std::mutex buffer_mutex;
     geom::PixelFormat surface_pf;
 };

=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2013-11-07 01:34:35 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2013-11-14 23:10:20 +0000
@@ -42,6 +42,10 @@
 protected:
     static void SetUpTestCase()
     {
+        /* note: exynos5 hwc driver can sends sigterm to vsync thread when closing hwc.
+           the server can handle this, but we need the test to as well */
+        original_sigterm_handler = signal(SIGTERM, [](int){});
+
         /* note about fb_device: OMAP4 drivers seem to only be able to open fb once
            per process (repeated framebuffer_{open,close}() doesn't seem to work). once we
            figure out why, we can remove fb_device in the test fixture */
@@ -52,14 +56,17 @@
 
     static void TearDownTestCase()
     {
+        signal(SIGTERM, original_sigterm_handler);
         display_resource_factory.reset();
     }
 
     md::glAnimationBasic gl_animation;
 
     static std::shared_ptr<mga::ResourceFactory> display_resource_factory;
+    static void (*original_sigterm_handler)(int);
 };
 
+void (*AndroidGPUDisplay::original_sigterm_handler)(int);
 std::shared_ptr<mga::ResourceFactory> AndroidGPUDisplay::display_resource_factory;
 }
 

=== modified file 'tests/unit-tests/client/android/test_android_native_window.cpp'
--- tests/unit-tests/client/android/test_android_native_window.cpp	2013-10-28 16:35:51 +0000
+++ tests/unit-tests/client/android/test_android_native_window.cpp	2013-11-14 23:10:20 +0000
@@ -176,15 +176,19 @@
     using namespace testing;
 
     ANativeWindowBuffer* returned_buffer;
-    auto fake_buffer = std::make_shared<mtd::StubAndroidNativeBuffer>();
+    auto mock_buffer = std::make_shared<mtd::MockAndroidNativeBuffer>();
     std::shared_ptr<ANativeWindow> window = std::make_shared<mga::MirNativeWindow>(mock_driver_interpreter);
 
     EXPECT_CALL(*mock_driver_interpreter, driver_requests_buffer())
         .Times(1)
-        .WillOnce(Return(fake_buffer.get()));
+        .WillOnce(Return(mock_buffer.get()));
+    EXPECT_CALL(*mock_buffer, wait_for_content())
+        .Times(1);
+    EXPECT_CALL(*mock_buffer, copy_fence())
+        .Times(0);
 
     window->dequeueBuffer_DEPRECATED(window.get(), &returned_buffer);
-    EXPECT_EQ(fake_buffer->anwb(), returned_buffer);
+    EXPECT_EQ(mock_buffer->anwb(), returned_buffer);
 }
 
 /* queue hook tests */

=== modified file 'tests/unit-tests/graphics/android/test_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_fb_device.cpp	2013-10-24 18:32:25 +0000
+++ tests/unit-tests/graphics/android/test_fb_device.cpp	2013-11-14 23:10:20 +0000
@@ -19,13 +19,16 @@
 #include "mir_test_doubles/mock_fb_hal_device.h"
 #include "mir_test_doubles/mock_buffer.h"
 #include "src/server/graphics/android/fb_device.h"
+#include "mir_test_doubles/mock_framebuffer_bundle.h"
 #include "mir_test_doubles/mock_android_hw.h"
 #include "mir_test_doubles/mock_egl.h"
+#include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/mock_android_native_buffer.h"
 
 #include <gtest/gtest.h>
 #include <stdexcept>
 
+namespace mg=mir::graphics;
 namespace mtd=mir::test::doubles;
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
@@ -42,15 +45,18 @@
         fbnum = 4;
         format = HAL_PIXEL_FORMAT_RGBA_8888;
 
+        mock_fb_bundle = std::make_shared<testing::NiceMock<mtd::MockFBBundle>>();
         fb_hal_mock = std::make_shared<mtd::MockFBHalDevice>(width, height, format, fbnum); 
         mock_buffer = std::make_shared<NiceMock<mtd::MockBuffer>>();
-
         native_buffer = std::make_shared<mtd::StubAndroidNativeBuffer>(); 
         ON_CALL(*mock_buffer, native_buffer_handle())
             .WillByDefault(Return(native_buffer));
+        ON_CALL(*mock_fb_bundle, last_rendered_buffer())
+            .WillByDefault(Return(mock_buffer)); 
     }
 
     unsigned int width, height, format, fbnum;
+    std::shared_ptr<mtd::MockFBBundle> mock_fb_bundle;
     std::shared_ptr<mtd::MockFBHalDevice> fb_hal_mock;
     std::shared_ptr<mtd::MockBuffer> mock_buffer;
     std::shared_ptr<mir::graphics::NativeBuffer> native_buffer;
@@ -58,31 +64,6 @@
     mtd::MockEGL mock_egl;
 };
 
-TEST_F(FBDevice, set_next_frontbuffer_ok)
-{
-    using namespace testing;
-    mga::FBDevice fbdev(fb_hal_mock);
-
-    EXPECT_CALL(*fb_hal_mock, post_interface(fb_hal_mock.get(), native_buffer->handle()))
-        .Times(1);
-
-    fbdev.set_next_frontbuffer(mock_buffer); 
-}
-
-TEST_F(FBDevice, set_next_frontbuffer_fail)
-{
-    using namespace testing;
-    mga::FBDevice fbdev(fb_hal_mock);
-
-    EXPECT_CALL(*fb_hal_mock, post_interface(fb_hal_mock.get(),native_buffer->handle()))
-        .Times(1)
-        .WillOnce(Return(-1));
-
-    EXPECT_THROW({
-        fbdev.set_next_frontbuffer(mock_buffer); 
-    }, std::runtime_error); 
-}
-
 TEST_F(FBDevice, commit_frame)
 {
     using namespace testing;
@@ -90,24 +71,43 @@
     EGLDisplay dpy = static_cast<EGLDisplay>(&bad);
     EGLSurface surf = static_cast<EGLSurface>(&bad);
     EXPECT_CALL(mock_egl, eglSwapBuffers(dpy,surf))
-        .Times(2)
+        .Times(3)
         .WillOnce(Return(EGL_FALSE))
+        .WillOnce(Return(EGL_TRUE))
         .WillOnce(Return(EGL_TRUE));
 
-    mga::FBDevice fbdev(fb_hal_mock);
-
+    EXPECT_CALL(*fb_hal_mock, post_interface(fb_hal_mock.get(), native_buffer->handle()))
+        .Times(2)
+        .WillOnce(Return(-1))
+        .WillOnce(Return(0));
+
+    mga::FBDevice fbdev(fb_hal_mock, mock_fb_bundle);
+
+    EXPECT_THROW({
+        fbdev.commit_frame(dpy, surf);
+    }, std::runtime_error);
     EXPECT_THROW({
         fbdev.commit_frame(dpy, surf);
     }, std::runtime_error);
     fbdev.commit_frame(dpy, surf);
 }
 
+TEST_F(FBDevice, buffer_for_render)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_fb_bundle, buffer_for_render())
+        .Times(1)
+        .WillOnce(Return(mock_buffer));
+    mga::FBDevice fbdev(fb_hal_mock, mock_fb_bundle);
+
+    EXPECT_EQ(mock_buffer, fbdev.buffer_for_render());
+}
 
 TEST_F(FBDevice, set_swapinterval)
 {
     EXPECT_CALL(*fb_hal_mock, setSwapInterval_interface(fb_hal_mock.get(), 1))
         .Times(1);
-    mga::FBDevice fbdev(fb_hal_mock);
+    mga::FBDevice fbdev(fb_hal_mock, mock_fb_bundle);
 
     testing::Mock::VerifyAndClearExpectations(fb_hal_mock.get());
 
@@ -119,34 +119,6 @@
 TEST_F(FBDevice, set_swapinterval_with_nullhook)
 {
     fb_hal_mock->setSwapInterval = nullptr;
-    mga::FBDevice fbdev(fb_hal_mock);
+    mga::FBDevice fbdev(fb_hal_mock, mock_fb_bundle);
     fbdev.sync_to_display(false);
 }
-
-TEST_F(FBDevice, determine_size)
-{
-    mga::FBDevice fbdev(fb_hal_mock);
-    auto size = fbdev.display_size();
-    EXPECT_EQ(width, size.width.as_uint32_t());
-    EXPECT_EQ(height, size.height.as_uint32_t());
-}
-
-TEST_F(FBDevice, determine_fbnum)
-{
-    mga::FBDevice fbdev(fb_hal_mock);
-    EXPECT_EQ(fbnum, fbdev.number_of_framebuffers_available());
-}
-
-//some drivers incorrectly report 0 buffers available. if this is true, we should alloc 2, the minimum requirement
-TEST_F(FBDevice, determine_fbnum_always_reports_2_minimum)
-{
-    auto slightly_malformed_fb_hal_mock = std::make_shared<mtd::MockFBHalDevice>(width, height, format, 0); 
-    mga::FBDevice fbdev(slightly_malformed_fb_hal_mock);
-    EXPECT_EQ(2u, fbdev.number_of_framebuffers_available());
-}
-
-TEST_F(FBDevice, determine_pixformat)
-{
-    mga::FBDevice fbdev(fb_hal_mock);
-    EXPECT_EQ(geom::PixelFormat::abgr_8888, fbdev.display_format());
-}

=== modified file 'tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp'
--- tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp	2013-11-14 23:10:20 +0000
@@ -16,8 +16,12 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "src/server/graphics/android/fb_simple_swapper.h"
+#include "src/server/graphics/android/framebuffers.h"
+#include "src/server/graphics/android/graphic_buffer_allocator.h"
 #include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_hwc_composer_device_1.h"
+#include "mir_test_doubles/mock_egl.h"
+#include "mir_test_doubles/mock_fb_hal_device.h"
 
 #include <future>
 #include <initializer_list>
@@ -28,123 +32,192 @@
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mtd=mir::test::doubles;
-
-class FBSimpleSwapperTest : public ::testing::Test
+namespace geom=mir::geometry;
+
+namespace
+{
+
+struct MockGraphicBufferAllocator : public mga::GraphicBufferAllocator
+{
+    MOCK_METHOD3(alloc_buffer_platform, std::shared_ptr<mg::Buffer>(
+        geom::Size, geom::PixelFormat, mga::BufferUsage use));
+};
+
+static int const display_width = 180;
+static int const display_height = 1010101;
+
+class PostingFBBundleTest : public ::testing::Test
 {
 public:
     virtual void SetUp()
     {
+        using namespace testing;
+        fbnum = 2;
+        format = HAL_PIXEL_FORMAT_RGBA_8888;
         buffer1 = std::make_shared<mtd::MockBuffer>();
         buffer2 = std::make_shared<mtd::MockBuffer>();
         buffer3 = std::make_shared<mtd::MockBuffer>();
+        mock_allocator = std::make_shared<MockGraphicBufferAllocator>();
+        mock_hwc_device = std::make_shared<testing::NiceMock<mtd::MockHWCComposerDevice1>>();
+        mock_fb_hal = std::make_shared<mtd::MockFBHalDevice>(display_width, display_height, format, fbnum); 
+        EXPECT_CALL(*mock_allocator, alloc_buffer_platform(_,_,_))
+            .Times(AtLeast(0))
+            .WillOnce(Return(buffer1))
+            .WillOnce(Return(buffer2))
+            .WillRepeatedly(Return(buffer3));
     }
 
+    int format;
+    int fbnum;
+    std::shared_ptr<mtd::MockFBHalDevice> mock_fb_hal;
+    std::shared_ptr<MockGraphicBufferAllocator> mock_allocator;
     std::shared_ptr<mg::Buffer> buffer1;
     std::shared_ptr<mg::Buffer> buffer2;
     std::shared_ptr<mg::Buffer> buffer3;
+    std::shared_ptr<mtd::MockHWCComposerDevice1> mock_hwc_device;
+    testing::NiceMock<mtd::MockEGL> mock_egl;
 };
 
-TEST_F(FBSimpleSwapperTest, simple_swaps_returns_valid)
-{
-    std::initializer_list<std::shared_ptr<mg::Buffer>> double_list{buffer1, buffer2};
-    mga::FBSimpleSwapper fb_swapper(double_list);
-
-    auto test_buffer = fb_swapper.compositor_acquire();
-
+static int display_attribute_handler(struct hwc_composer_device_1*, int, uint32_t,
+                                     const uint32_t* attribute_list, int32_t* values)
+{
+    EXPECT_EQ(attribute_list[0], HWC_DISPLAY_WIDTH);
+    EXPECT_EQ(attribute_list[1], HWC_DISPLAY_HEIGHT);
+    EXPECT_EQ(attribute_list[2], HWC_DISPLAY_NO_ATTRIBUTE);
+
+    values[0] = display_width;
+    values[1] = display_height;
+    return 0;
+}
+}
+
+TEST_F(PostingFBBundleTest, hwc_fb_size_allocation)
+{
+    using namespace testing;
+
+    unsigned int hwc_configs = 0xA1;
+    EXPECT_CALL(*mock_hwc_device, getDisplayConfigs_interface(mock_hwc_device.get(),HWC_DISPLAY_PRIMARY,_,Pointee(1)))
+        .Times(1)
+        .WillOnce(DoAll(SetArgPointee<2>(hwc_configs), Return(0)));
+    EXPECT_CALL(*mock_hwc_device, getDisplayAttributes_interface(mock_hwc_device.get(), HWC_DISPLAY_PRIMARY, hwc_configs,_,_))
+        .Times(1)
+        .WillOnce(Invoke(display_attribute_handler));
+   
+    auto display_size = mir::geometry::Size{display_width, display_height};
+    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(display_size, _, mga::BufferUsage::use_framebuffer_gles))
+        .Times(2)
+        .WillRepeatedly(Return(nullptr));
+
+    mga::Framebuffers framebuffers(mock_allocator, mock_hwc_device);
+    EXPECT_EQ(display_size, framebuffers.fb_size());
+}
+
+TEST_F(PostingFBBundleTest, hwc_fb_format_selection)
+{
+    using namespace testing;
+    EGLint const expected_egl_config_attr [] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
+        EGL_NONE
+    };
+
+    int visual_id = HAL_PIXEL_FORMAT_BGRA_8888;
+    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
+    EGLConfig fake_egl_config = reinterpret_cast<EGLConfig>(0x44);
+
+    Sequence seq;
+    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
+        .InSequence(seq)
+        .WillOnce(Return(fake_display));
+    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
+        .InSequence(seq);
+    EXPECT_CALL(mock_egl, eglChooseConfig(fake_display,mtd::AttrMatches(expected_egl_config_attr),_,1,_))
+        .InSequence(seq)
+        .WillOnce(DoAll(SetArgPointee<2>(fake_egl_config), SetArgPointee<4>(1), Return(EGL_TRUE)));
+    EXPECT_CALL(mock_egl, eglGetConfigAttrib(fake_display, fake_egl_config, EGL_NATIVE_VISUAL_ID, _))
+        .InSequence(seq)
+        .WillOnce(DoAll(SetArgPointee<3>(visual_id), Return(EGL_TRUE)));
+    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
+        .InSequence(seq);
+ 
+    mga::Framebuffers framebuffers(mock_allocator, mock_hwc_device);
+    EXPECT_EQ(geom::PixelFormat::argb_8888, framebuffers.fb_format());
+}
+
+//apparently this can happen if the display is in the 'unplugged state'
+TEST_F(PostingFBBundleTest, test_hwc_device_display_config_failure_throws)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_hwc_device, getDisplayConfigs_interface(mock_hwc_device.get(),HWC_DISPLAY_PRIMARY,_,_))
+        .Times(1)
+        .WillOnce(Return(-1));
+
+    EXPECT_THROW({
+        mga::Framebuffers framebuffers(mock_allocator, mock_hwc_device);
+    }, std::runtime_error);
+}
+
+
+//not all hwc11 implementations give a hint about their framebuffer formats in their configuration.
+//prefer abgr_8888 if we can't figure things out
+TEST_F(PostingFBBundleTest, hwc_version_11_format_selection_failure)
+{
+    using namespace testing;
+    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
+
+    Sequence seq;
+    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
+        .InSequence(seq)
+        .WillOnce(Return(fake_display));
+    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
+        .InSequence(seq);
+    EXPECT_CALL(mock_egl, eglChooseConfig(_,_,_,_,_))
+        .InSequence(seq)
+        .WillOnce(DoAll(SetArgPointee<4>(0), Return(EGL_TRUE)));
+    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
+        .InSequence(seq);
+    
+    mga::Framebuffers framebuffers(mock_allocator, mock_hwc_device);
+    EXPECT_EQ(geom::PixelFormat::abgr_8888, framebuffers.fb_format());
+}
+
+TEST_F(PostingFBBundleTest, bundle_from_fb)
+{
+    using namespace testing;
+    auto display_size = geom::Size{display_width, display_height};
+    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(display_size, geom::PixelFormat::abgr_8888, mga::BufferUsage::use_framebuffer_gles))
+        .Times(fbnum)
+        .WillRepeatedly(Return(nullptr));
+
+    mga::Framebuffers framebuffers(mock_allocator, mock_fb_hal);
+    EXPECT_EQ(display_size, framebuffers.fb_size());
+    EXPECT_EQ(geom::PixelFormat::abgr_8888, framebuffers.fb_format());
+}
+
+//some drivers incorrectly report 0 buffers available. if this is true, we should alloc 2, the minimum requirement
+TEST_F(PostingFBBundleTest, determine_fbnum_always_reports_2_minimum)
+{
+    using namespace testing;
+    auto slightly_malformed_fb_hal_mock = std::make_shared<mtd::MockFBHalDevice>(display_width, display_height, format, 0); 
+    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(_,_,_))
+        .Times(2)
+        .WillRepeatedly(Return(nullptr));
+
+    mga::Framebuffers framebuffers(mock_allocator, slightly_malformed_fb_hal_mock);
+}
+
+TEST_F(PostingFBBundleTest, last_rendered_returns_valid)
+{
+    mga::Framebuffers framebuffers(mock_allocator, mock_fb_hal);
+
+    auto test_buffer = framebuffers.last_rendered_buffer();
     EXPECT_TRUE((test_buffer == buffer1) || (test_buffer == buffer2));
-} 
-
-TEST_F(FBSimpleSwapperTest, simple_swaps_return_aba_pattern)
-{
-    std::initializer_list<std::shared_ptr<mg::Buffer>> double_list{buffer1, buffer2};
-    mga::FBSimpleSwapper fb_swapper(double_list);
-
-    auto test_buffer_1 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_1);
-
-    auto test_buffer_2 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_2);
-
-    auto test_buffer_3 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_3);
-
-    EXPECT_EQ(test_buffer_1, test_buffer_3);
-    EXPECT_NE(test_buffer_1, test_buffer_2);
-} 
-
-TEST_F(FBSimpleSwapperTest, triple_swaps_return_abcab_pattern)
-{
-    std::initializer_list<std::shared_ptr<mg::Buffer>> triple_list{buffer1, buffer2, buffer3};
-    mga::FBSimpleSwapper fb_swapper(triple_list);
-
-    auto test_buffer_1 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_1);
-
-    auto test_buffer_2 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_2);
-
-    auto test_buffer_3 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_3);
-
-    auto test_buffer_4 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_4);
-
-    auto test_buffer_5 = fb_swapper.compositor_acquire();
-    fb_swapper.compositor_release(test_buffer_5);
-
-    EXPECT_EQ(test_buffer_1, test_buffer_4);
-    EXPECT_NE(test_buffer_1, test_buffer_2);
-    EXPECT_NE(test_buffer_1, test_buffer_3);
-
-    EXPECT_EQ(test_buffer_2, test_buffer_5);
-    EXPECT_NE(test_buffer_2, test_buffer_1);
-    EXPECT_NE(test_buffer_2, test_buffer_3);
-}
-
-TEST_F(FBSimpleSwapperTest, synctest)
-{
-    std::vector<std::shared_ptr<mg::Buffer>> test_buffers{buffer1, buffer2};
-    mga::FBSimpleSwapper fb_swapper(test_buffers);
-
-    std::vector<std::shared_ptr<mg::Buffer>> blist;
-    std::mutex mut;
-    for(auto i=0u; i < 150; ++i)
-    {
-        auto buf1 = fb_swapper.compositor_acquire();
-        auto buf2 = fb_swapper.compositor_acquire();
-
-        auto f = std::async(std::launch::async,
-                            [&]()
-                            {
-                                /* driver will release in order */
-                                fb_swapper.compositor_release(buf1);
-                                fb_swapper.compositor_release(buf2);
-                            });
-
-        //this line will wait if f has not run
-        auto buf3 = fb_swapper.compositor_acquire();
-        f.wait(); //make sure buf3 is released after buf2 to maintain order
-        fb_swapper.compositor_release(buf3);
-
-        blist.push_back(buf1);
-        blist.push_back(buf2);
-        blist.push_back(buf3);
-    }
-
-    //This chunk of code makes sure "ABABA..." or "BABAB..." pattern was produced 
-    auto modcounter = 0u;
-    for(auto i : test_buffers)
-    {
-        if (blist[0] == i)
-        {
-            break;
-        }
-        modcounter++;
-    }
-
-    for(auto i : blist)
-    {
-        EXPECT_EQ(test_buffers[(modcounter % test_buffers.size())], i);
-        modcounter++;
-    }
-}
+
+    auto first_buffer = framebuffers.buffer_for_render();
+    auto first_buffer_ptr = first_buffer.get();
+    EXPECT_NE(first_buffer, framebuffers.last_rendered_buffer());
+    first_buffer.reset();
+    EXPECT_EQ(first_buffer_ptr, framebuffers.last_rendered_buffer().get());
+} 

=== modified file 'tests/unit-tests/graphics/android/test_hwc10_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc10_device.cpp	2013-11-08 18:44:35 +0000
+++ tests/unit-tests/graphics/android/test_hwc10_device.cpp	2013-11-14 23:10:20 +0000
@@ -21,6 +21,7 @@
 #include "mir_test_doubles/mock_hwc_composer_device_1.h"
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/mock_hwc_vsync_coordinator.h"
+#include "mir_test_doubles/mock_framebuffer_bundle.h"
 #include <gtest/gtest.h>
 #include <stdexcept>
 
@@ -41,6 +42,8 @@
         mock_device = std::make_shared<testing::NiceMock<mtd::MockHWCComposerDevice1>>();
         mock_fbdev = std::make_shared<mtd::MockDisplayDevice>();
         mock_vsync = std::make_shared<testing::NiceMock<mtd::MockVsyncCoordinator>>();
+        mock_buffer = std::make_shared<NiceMock<mtd::MockBuffer>>();
+        mock_fb_bundle = std::make_shared<testing::NiceMock<mtd::MockFBBundle>>();
     }
 
     geom::PixelFormat test_pf;
@@ -49,16 +52,19 @@
     std::shared_ptr<mtd::MockHWCComposerDevice1> mock_device;
     std::shared_ptr<mtd::MockDisplayDevice> mock_fbdev;
     std::shared_ptr<mtd::MockVsyncCoordinator> mock_vsync;
+    std::shared_ptr<mtd::MockFBBundle> mock_fb_bundle;
+    std::shared_ptr<mtd::MockBuffer> mock_buffer;
 };
 
-TEST_F(HWC10Device, hwc10_set_next_frontbuffer)
+TEST_F(HWC10Device, buffer_for_render)
 {
-    std::shared_ptr<mg::Buffer> mock_buffer = std::make_shared<mtd::MockBuffer>();
-    EXPECT_CALL(*mock_fbdev, set_next_frontbuffer(mock_buffer))
-        .Times(1);
+    using namespace testing;
+    EXPECT_CALL(*mock_fb_bundle, buffer_for_render())
+        .Times(1)
+        .WillOnce(Return(mock_buffer));
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
-    device.set_next_frontbuffer(mock_buffer);
+    EXPECT_EQ(mock_buffer, device.buffer_for_render());
 }
 
 TEST_F(HWC10Device, hwc10_commit_frame_sync)
@@ -77,7 +83,7 @@
     EXPECT_CALL(*mock_vsync, wait_for_vsync())
         .Times(1);
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
 
     device.commit_frame(dpy, sur);
 
@@ -110,7 +116,7 @@
     EXPECT_CALL(*mock_vsync, wait_for_vsync())
         .Times(0);
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
     device.sync_to_display(false);
 
     device.commit_frame(dpy, sur);
@@ -126,7 +132,7 @@
         .Times(1)
         .WillOnce(Return(-1));
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
 
     EXPECT_THROW({
         device.commit_frame(dpy, sur);
@@ -143,7 +149,7 @@
         .Times(1)
         .WillOnce(Return(-1));
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
 
     EXPECT_THROW({
         device.commit_frame(dpy, sur);
@@ -159,12 +165,8 @@
     EXPECT_CALL(*mock_fbdev, display_format())
         .Times(1)
         .WillOnce(Return(test_pf));
-    EXPECT_CALL(*mock_fbdev, number_of_framebuffers_available())
-        .Times(1)
-        .WillOnce(Return(test_numfb));
 
-    mga::HWC10Device device(mock_device, mock_fbdev, mock_vsync);
+    mga::HWC10Device device(mock_device, mock_fb_bundle, mock_fbdev, mock_vsync);
     EXPECT_EQ(test_size, device.display_size());
     EXPECT_EQ(test_pf, device.display_format());
-    EXPECT_EQ(test_numfb, device.number_of_framebuffers_available());
 }

=== modified file 'tests/unit-tests/graphics/android/test_hwc11_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc11_device.cpp	2013-11-08 18:25:19 +0000
+++ tests/unit-tests/graphics/android/test_hwc11_device.cpp	2013-11-14 23:10:20 +0000
@@ -16,12 +16,17 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
+#include "src/server/graphics/android/framebuffer_bundle.h"
 #include "src/server/graphics/android/hwc11_device.h"
 #include "src/server/graphics/android/hwc_layerlist.h"
 #include "mir_test_doubles/mock_hwc_composer_device_1.h"
+#include "mir_test_doubles/mock_android_native_buffer.h"
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/mock_hwc_vsync_coordinator.h"
 #include "mir_test_doubles/mock_egl.h"
+#include "mir_test_doubles/mock_framebuffer_bundle.h"
+#include "mir_test_doubles/stub_buffer.h"
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <stdexcept>
 
@@ -35,207 +40,98 @@
 protected:
     virtual void SetUp()
     {
+        using namespace testing;
+
+        mock_native_buffer = std::make_shared<testing::NiceMock<mtd::MockAndroidNativeBuffer>>();
+        mock_buffer = std::make_shared<testing::NiceMock<mtd::MockBuffer>>();
+        mock_fb_bundle = std::make_shared<testing::NiceMock<mtd::MockFBBundle>>();
         mock_device = std::make_shared<testing::NiceMock<mtd::MockHWCComposerDevice1>>();
         mock_vsync = std::make_shared<testing::NiceMock<mtd::MockVsyncCoordinator>>();
+
+        ON_CALL(*mock_buffer, native_buffer_handle())
+            .WillByDefault(Return(mock_native_buffer));
+        ON_CALL(*mock_fb_bundle, last_rendered_buffer())
+            .WillByDefault(Return(mock_buffer));
     }
 
+    std::shared_ptr<mtd::MockFBBundle> mock_fb_bundle;
     std::shared_ptr<mtd::MockVsyncCoordinator> mock_vsync;
     std::shared_ptr<mtd::MockHWCComposerDevice1> mock_device;
+    std::shared_ptr<mtd::MockAndroidNativeBuffer> mock_native_buffer;
+    std::shared_ptr<mtd::MockBuffer> mock_buffer;
     EGLDisplay dpy;
     EGLSurface surf;
     testing::NiceMock<mtd::MockEGL> mock_egl;
 };
 
-TEST_F(HWC11Device, test_hwc_gles_set_empty_layerlist)
-{
-    using namespace testing;
-
-    mga::HWC11Device device(mock_device, mock_vsync);
-
-    EXPECT_CALL(*mock_device, set_interface(mock_device.get(), 1, _))
-        .Times(1);
-    device.commit_frame(dpy, surf);
-
-    EXPECT_EQ(1, mock_device->display0_set_content.numHwLayers);
-    EXPECT_EQ(-1, mock_device->display0_set_content.retireFenceFd);
-}
-
-TEST_F(HWC11Device, test_hwc_gles_set_error)
-{
-    using namespace testing;
-
-    mga::HWC11Device device(mock_device, mock_vsync);
-
-    EXPECT_CALL(*mock_device, set_interface(mock_device.get(), 1, _))
-        .Times(1)
-        .WillOnce(Return(-1));
-
-    EXPECT_THROW({
-        device.commit_frame(dpy, surf);
-    }, std::runtime_error);
-}
-
-TEST_F(HWC11Device, test_hwc_gles_commit_swapbuffers_failure)
-{
-    using namespace testing;
-    EXPECT_CALL(mock_egl, eglSwapBuffers(dpy,surf))
-        .Times(1)
-        .WillOnce(Return(EGL_FALSE));
-
-    mga::HWC11Device device(mock_device, mock_vsync);
-
-    EXPECT_THROW({
-        device.commit_frame(dpy, surf);
-    }, std::runtime_error);
-}
-
-TEST_F(HWC11Device, test_hwc_commit_order_with_vsync)
-{
-    using namespace testing;
-
-    mga::HWC11Device device(mock_device, mock_vsync);
-
-    //the order here is very important. eglSwapBuffers will alter the layerlist,
-    //so it must come before assembling the data for set
+TEST_F(HWC11Device, test_hwc_commit_order)
+{
+    using namespace testing;
+    int hwc_return_fence = 94;
+    mock_device->hwc_set_return_fence(hwc_return_fence);
+
+    mga::HWC11Device device(mock_device, mock_fb_bundle, mock_vsync);
+
     InSequence seq;
     EXPECT_CALL(*mock_device, prepare_interface(mock_device.get(), 1, _))
         .Times(1);
     EXPECT_CALL(mock_egl, eglSwapBuffers(dpy,surf))
         .Times(1);
+    EXPECT_CALL(*mock_fb_bundle, last_rendered_buffer())
+        .Times(1);
     EXPECT_CALL(*mock_device, set_interface(mock_device.get(), 1, _))
         .Times(1);
+    EXPECT_CALL(*mock_native_buffer, update_fence(hwc_return_fence))
+        .Times(1);
 
     device.commit_frame(dpy, surf);
 
-    EXPECT_EQ(1, mock_device->display0_prepare_content.numHwLayers);
+    EXPECT_EQ(2, mock_device->display0_prepare_content.numHwLayers);
     EXPECT_EQ(-1, mock_device->display0_prepare_content.retireFenceFd);
-    EXPECT_EQ(1, mock_device->display0_set_content.numHwLayers);
+    //set
+    EXPECT_EQ(2, mock_device->display0_set_content.numHwLayers);
     EXPECT_EQ(-1, mock_device->display0_set_content.retireFenceFd);
+    EXPECT_EQ(HWC_FRAMEBUFFER, mock_device->set_layerlist[0].compositionType);
+    EXPECT_EQ(HWC_SKIP_LAYER, mock_device->set_layerlist[0].flags);
+    EXPECT_EQ(HWC_FRAMEBUFFER_TARGET, mock_device->set_layerlist[1].compositionType);
+    EXPECT_EQ(0, mock_device->set_layerlist[1].flags);
 }
 
-TEST_F(HWC11Device, test_hwc_device_display_config)
+TEST_F(HWC11Device, buffer_for_render)
 {
     using namespace testing;
-
-    unsigned int hwc_configs = 0xA1;
-    EXPECT_CALL(*mock_device, getDisplayConfigs_interface(mock_device.get(),HWC_DISPLAY_PRIMARY,_,Pointee(1)))
+    EXPECT_CALL(*mock_fb_bundle, buffer_for_render())
         .Times(1)
-        .WillOnce(DoAll(SetArgPointee<2>(hwc_configs), Return(0)));
-
-    mga::HWC11Device device(mock_device, mock_vsync);
+        .WillOnce(Return(mock_buffer));
+    mga::HWC11Device device(mock_device, mock_fb_bundle, mock_vsync);
+    EXPECT_EQ(mock_buffer, device.buffer_for_render());
 }
 
-
-//apparently this can happen if the display is in the 'unplugged state'
-TEST_F(HWC11Device, test_hwc_device_display_config_failure_throws)
+TEST_F(HWC11Device, test_hwc_commit_failure)
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_device, getDisplayConfigs_interface(mock_device.get(),HWC_DISPLAY_PRIMARY,_,_))
+    mga::HWC11Device device(mock_device, mock_fb_bundle, mock_vsync);
+
+    EXPECT_CALL(*mock_device, set_interface(mock_device.get(), 1, _))
         .Times(1)
         .WillOnce(Return(-1));
 
     EXPECT_THROW({
-        mga::HWC11Device device(mock_device, mock_vsync);
-    }, std::runtime_error);
-}
-
-namespace
-{
-static int const display_width = 180;
-static int const display_height = 1010101;
-
-static int display_attribute_handler(struct hwc_composer_device_1*, int, uint32_t,
-                                     const uint32_t* attribute_list, int32_t* values)
-{
-    EXPECT_EQ(attribute_list[0], HWC_DISPLAY_WIDTH);
-    EXPECT_EQ(attribute_list[1], HWC_DISPLAY_HEIGHT);
-    EXPECT_EQ(attribute_list[2], HWC_DISPLAY_NO_ATTRIBUTE);
-
-    values[0] = display_width;
-    values[1] = display_height;
-    return 0;
-}
-}
-
-TEST_F(HWC11Device, test_hwc_device_display_width_height)
-{
-    using namespace testing;
-
-    int hwc_configs = 0xA1;
-    EXPECT_CALL(*mock_device, getDisplayConfigs_interface(mock_device.get(),HWC_DISPLAY_PRIMARY,_,_))
-        .Times(1)
-        .WillOnce(DoAll(SetArgPointee<2>(hwc_configs), Return(0)));
-    EXPECT_CALL(*mock_device, getDisplayAttributes_interface(mock_device.get(), HWC_DISPLAY_PRIMARY,hwc_configs,_,_))
-        .Times(1)
-        .WillOnce(Invoke(display_attribute_handler));
-
-    mga::HWC11Device device(mock_device, mock_vsync);
- 
-    auto size = device.display_size();
-    EXPECT_EQ(size.width.as_uint32_t(),  static_cast<unsigned int>(display_width));
-    EXPECT_EQ(size.height.as_uint32_t(), static_cast<unsigned int>(display_height));
-}
-
-TEST_F(HWC11Device, hwc_device_reports_2_fbs_available_by_default)
-{
-    mga::HWC11Device device(mock_device, mock_vsync);
-    EXPECT_EQ(2u, device.number_of_framebuffers_available());
-}
-
-TEST_F(HWC11Device, hwc_version_11_format_selection)
-{
-    using namespace testing;
-    EGLint const expected_egl_config_attr [] =
-    {
-        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
-        EGL_NONE
-    };
-
-    int visual_id = HAL_PIXEL_FORMAT_BGRA_8888;
-    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
-    EGLConfig fake_egl_config = reinterpret_cast<EGLConfig>(0x44);
-
-    Sequence seq;
-    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
-        .InSequence(seq)
-        .WillOnce(Return(fake_display));
-    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
-        .InSequence(seq);
-    EXPECT_CALL(mock_egl, eglChooseConfig(fake_display,mtd::AttrMatches(expected_egl_config_attr),_,1,_))
-        .InSequence(seq)
-        .WillOnce(DoAll(SetArgPointee<2>(fake_egl_config), SetArgPointee<4>(1), Return(EGL_TRUE)));
-    EXPECT_CALL(mock_egl, eglGetConfigAttrib(fake_display, fake_egl_config, EGL_NATIVE_VISUAL_ID, _))
-        .InSequence(seq)
-        .WillOnce(DoAll(SetArgPointee<3>(visual_id), Return(EGL_TRUE)));
-    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
-        .InSequence(seq);
- 
-    mga::HWC11Device device(mock_device, mock_vsync);
-    EXPECT_EQ(geom::PixelFormat::argb_8888, device.display_format());
-}
-
-//not all hwc11 implementations give a hint about their framebuffer formats in their configuration.
-//prefer abgr_8888 if we can't figure things out
-TEST_F(HWC11Device, hwc_version_11_format_selection_failure)
-{
-    using namespace testing;
-    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
-
-    Sequence seq;
-    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
-        .InSequence(seq)
-        .WillOnce(Return(fake_display));
-    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
-        .InSequence(seq);
-    EXPECT_CALL(mock_egl, eglChooseConfig(_,_,_,_,_))
-        .InSequence(seq)
-        .WillOnce(DoAll(SetArgPointee<4>(0), Return(EGL_TRUE)));
-    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
-        .InSequence(seq);
-    
-    mga::HWC11Device device(mock_device, mock_vsync);
-    EXPECT_EQ(geom::PixelFormat::abgr_8888, device.display_format());
+        device.commit_frame(dpy, surf);
+    }, std::runtime_error);
+}
+
+TEST_F(HWC11Device, test_hwc_swapbuffers_failure)
+{
+    using namespace testing;
+    EXPECT_CALL(mock_egl, eglSwapBuffers(dpy,surf))
+        .Times(1)
+        .WillOnce(Return(EGL_FALSE));
+
+    mga::HWC11Device device(mock_device, mock_fb_bundle, mock_vsync);
+
+    EXPECT_THROW({
+        device.commit_frame(dpy, surf);
+    }, std::runtime_error);
 }

=== modified file 'tests/unit-tests/graphics/android/test_hwc_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_device.cpp	2013-11-08 18:25:19 +0000
+++ tests/unit-tests/graphics/android/test_hwc_device.cpp	2013-11-14 23:10:20 +0000
@@ -47,7 +47,7 @@
                                                 std::shared_ptr<mga::DisplayDevice> const& fbdev,
                                                 std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
 {
-    return std::make_shared<mga::HWC10Device>(hwc_device, fbdev, coordinator);
+    return std::make_shared<mga::HWC10Device>(hwc_device, nullptr, fbdev, coordinator);
 }
 
 template <>
@@ -56,7 +56,7 @@
                                                 std::shared_ptr<mga::DisplayDevice> const&,
                                                 std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
 {
-    return std::make_shared<mga::HWC11Device>(hwc_device, coordinator);
+    return std::make_shared<mga::HWC11Device>(hwc_device, nullptr, coordinator);
 }
 
 template<typename T>

=== modified file 'tests/unit-tests/graphics/android/test_hwc_layerlist.cpp'
--- tests/unit-tests/graphics/android/test_hwc_layerlist.cpp	2013-11-11 21:34:15 +0000
+++ tests/unit-tests/graphics/android/test_hwc_layerlist.cpp	2013-11-14 23:10:20 +0000
@@ -39,13 +39,13 @@
         native_handle_1 = std::make_shared<mtd::StubAndroidNativeBuffer>();
         native_handle_1->anwb()->width = width;
         native_handle_1->anwb()->height = height;
-        native_handle_2 = std::make_shared<mtd::StubAndroidNativeBuffer>();
+        native_handle_2 = std::make_shared<mtd::MockAndroidNativeBuffer>();
     }
 
     int width; 
     int height; 
     std::shared_ptr<mg::NativeBuffer> native_handle_1;
-    std::shared_ptr<mg::NativeBuffer> native_handle_2;
+    std::shared_ptr<mtd::MockAndroidNativeBuffer> native_handle_2;
 };
 
 TEST_F(HWCLayerListTest, fb_target_layer)
@@ -139,6 +139,12 @@
 TEST_F(HWCLayerListTest, hwc_list_update)
 {
     using namespace testing;
+
+    int handle_fence = 442;
+    EXPECT_CALL(*native_handle_2, copy_fence())
+        .Times(1)
+        .WillOnce(Return(handle_fence));
+
     mga::LayerList layerlist({
         mga::CompositionLayer(*native_handle_1, 0),
         mga::FramebufferLayer(*native_handle_1)});
@@ -146,6 +152,21 @@
 
     auto list = layerlist.native_list(); 
     ASSERT_EQ(2u, list->numHwLayers);
-    EXPECT_EQ(list->hwLayers[0].handle, native_handle_1->handle());
+    EXPECT_EQ(native_handle_1->handle(), list->hwLayers[0].handle);
+    EXPECT_EQ(-1, list->hwLayers[0].acquireFenceFd);
     EXPECT_EQ(list->hwLayers[1].handle, native_handle_2->handle());
+    EXPECT_EQ(handle_fence, list->hwLayers[1].acquireFenceFd);
+}
+
+TEST_F(HWCLayerListTest, get_fb_fence)
+{
+    int release_fence = 381;
+    mga::LayerList layerlist({
+        mga::CompositionLayer(*native_handle_1, 0),
+        mga::FramebufferLayer(*native_handle_1)});
+
+    auto list = layerlist.native_list();
+    list->hwLayers[1].releaseFenceFd = release_fence;
+
+    EXPECT_EQ(release_fence, layerlist.framebuffer_fence());
 }

=== modified file 'tests/unit-tests/graphics/android/test_resource_factory.cpp'
--- tests/unit-tests/graphics/android/test_resource_factory.cpp	2013-11-07 01:34:35 +0000
+++ tests/unit-tests/graphics/android/test_resource_factory.cpp	2013-11-14 23:10:20 +0000
@@ -42,7 +42,7 @@
 {
 public:
     MOCK_METHOD1(alloc_buffer, std::shared_ptr<mg::Buffer>(mg::BufferProperties const&));
-    MOCK_METHOD3(alloc_buffer_platform, std::shared_ptr<mga::Buffer>(geom::Size, geom::PixelFormat, mga::BufferUsage));
+    MOCK_METHOD3(alloc_buffer_platform, std::shared_ptr<mg::Buffer>(geom::Size, geom::PixelFormat, mga::BufferUsage));
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
 
     ~MockAndroidGraphicBufferAllocator() noexcept {}
@@ -64,11 +64,9 @@
             .WillByDefault(Return(geom::PixelFormat::abgr_8888));
         ON_CALL(*mock_display_device, display_size())
             .WillByDefault(Return(geom::Size{2, 3}));
-        ON_CALL(*mock_display_device, number_of_framebuffers_available())
-            .WillByDefault(Return(fake_fb_num));
 
         ON_CALL(*mock_buffer_allocator, alloc_buffer_platform(_,_,_))
-            .WillByDefault(Return(std::shared_ptr<mga::Buffer>()));
+            .WillByDefault(Return(std::shared_ptr<mg::Buffer>()));
     }
 
     std::shared_ptr<mtd::MockDisplayReport> mock_report;
@@ -79,34 +77,6 @@
     testing::NiceMock<mtd::MockEGL> mock_egl;
 };
 
-//note: @kdub imo, the hwc api has a hole in it that it doesn't allow query for format. surfaceflinger code
-//      makes note of this api hole in its comments too. It always uses rgba8888, which we try to do too.
-TEST_F(ResourceFactoryTest, test_native_window_creation_figures_out_fb_number)
-{
-    using namespace testing; 
-    geom::Width disp_width{44};
-    geom::Height disp_height{4567654};
-    geom::Size disp_size{disp_width, disp_height};
-    geom::PixelFormat pf = geom::PixelFormat::abgr_8888;  
- 
-    EXPECT_CALL(*mock_display_device, number_of_framebuffers_available())
-        .Times(AtLeast(1))
-        .WillOnce(Return(fake_fb_num));
-    EXPECT_CALL(*mock_display_device, display_size())
-        .Times(AtLeast(1))
-        .WillOnce(Return(disp_size));
-    EXPECT_CALL(*mock_display_device, display_format())
-        .Times(AtLeast(1))
-        .WillOnce(Return(pf));
-
-    EXPECT_CALL(*mock_buffer_allocator, alloc_buffer_platform(
-        disp_size,pf,mga::BufferUsage::use_framebuffer_gles))
-        .Times(fake_fb_num);
-
-    mga::ResourceFactory factory(mock_buffer_allocator);
-    factory.create_native_window(mock_display_device);
-}
-
 TEST_F(ResourceFactoryTest, fb_native_creation_opens_and_closes_gralloc)
 {
     using namespace testing;
@@ -140,7 +110,6 @@
     EXPECT_THROW({
         factory.create_fb_native_device();
     }, std::runtime_error);
-
 }
 
 TEST_F(ResourceFactoryTest, hwc_allocation)

=== modified file 'tests/unit-tests/graphics/android/test_server_interpreter.cpp'
--- tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-10-25 16:39:50 +0000
+++ tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-11-14 23:10:20 +0000
@@ -17,7 +17,6 @@
  */
 
 #include "src/server/graphics/android/server_render_window.h"
-#include "src/server/graphics/android/fb_swapper.h"
 
 #include "mir_test_doubles/mock_display_device.h"
 #include "mir_test_doubles/mock_buffer.h"
@@ -30,7 +29,6 @@
 #include <gmock/gmock.h>
 #include <stdexcept>
 
-
 namespace mt=mir::test;
 namespace mtd=mir::test::doubles;
 namespace geom=mir::geometry;
@@ -39,14 +37,6 @@
 
 namespace
 {
-
-struct MockFBSwapper : public mga::FBSwapper
-{
-    ~MockFBSwapper() noexcept {}
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<mg::Buffer>());
-    MOCK_METHOD1(compositor_release, void(std::shared_ptr<mg::Buffer> const& released_buffer));
-};
-
 struct ServerRenderWindowTest : public ::testing::Test
 {
     virtual void SetUp()
@@ -55,7 +45,6 @@
         mock_buffer1 = std::make_shared<NiceMock<mtd::MockBuffer>>();
         mock_buffer2 = std::make_shared<NiceMock<mtd::MockBuffer>>();
         mock_buffer3 = std::make_shared<NiceMock<mtd::MockBuffer>>();
-        mock_swapper = std::make_shared<NiceMock<MockFBSwapper>>();
         mock_display_device = std::make_shared<NiceMock<mtd::MockDisplayDevice>>();
         mock_cache = std::make_shared<mtd::MockInterpreterResourceCache>();
         ON_CALL(*mock_display_device, display_format())
@@ -66,7 +55,6 @@
     std::shared_ptr<mtd::MockBuffer> mock_buffer2;
     std::shared_ptr<mtd::MockBuffer> mock_buffer3;
     std::shared_ptr<mtd::MockInterpreterResourceCache> mock_cache;
-    std::shared_ptr<MockFBSwapper> mock_swapper;
     std::shared_ptr<mtd::MockDisplayDevice> mock_display_device;
 };
 }
@@ -75,11 +63,11 @@
 {
     using namespace testing;
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     auto stub_buffer = std::make_shared<mtd::StubAndroidNativeBuffer>();
 
-    EXPECT_CALL(*mock_swapper, compositor_acquire())
+    EXPECT_CALL(*mock_display_device, buffer_for_render())
         .Times(1)
         .WillOnce(Return(mock_buffer1));
     EXPECT_CALL(*mock_buffer1, native_buffer_handle())
@@ -101,9 +89,9 @@
     int fake_fence = 488;
     auto stub_buffer = std::make_shared<mtd::StubAndroidNativeBuffer>();
  
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
-    EXPECT_CALL(*mock_swapper, compositor_acquire())
+    EXPECT_CALL(*mock_display_device, buffer_for_render())
         .Times(1)
         .WillOnce(Return(mock_buffer1));
     EXPECT_CALL(*mock_buffer1, native_buffer_handle())
@@ -111,7 +99,7 @@
         .WillOnce(Return(stub_buffer));
 
     render_window.driver_requests_buffer();
-    testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
+    testing::Mock::VerifyAndClearExpectations(mock_display_device.get());
 
     std::shared_ptr<mg::Buffer> buf1 = mock_buffer1;
     EXPECT_CALL(*mock_cache, update_native_fence(stub_buffer->anwb(), fake_fence))
@@ -119,13 +107,9 @@
     EXPECT_CALL(*mock_cache, retrieve_buffer(stub_buffer->anwb()))
         .Times(1)
         .WillOnce(Return(mock_buffer1));
-    EXPECT_CALL(*mock_swapper, compositor_release(buf1))
-        .Times(1); 
-    EXPECT_CALL(*mock_display_device, set_next_frontbuffer(buf1))
-        .Times(1);
 
     render_window.driver_returns_buffer(stub_buffer->anwb(), fake_fence);
-    testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
+    testing::Mock::VerifyAndClearExpectations(mock_display_device.get());
 }
 
 TEST_F(ServerRenderWindowTest, driver_inquires_about_format)
@@ -136,7 +120,7 @@
         .Times(1)
         .WillOnce(Return(geom::PixelFormat::abgr_8888));
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     EXPECT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, render_window.driver_requests_info(NATIVE_WINDOW_FORMAT));
 }
@@ -145,7 +129,7 @@
 {
     using namespace testing;
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     render_window.dispatch_driver_request_format(HAL_PIXEL_FORMAT_RGBX_8888);
     auto rc_format = render_window.driver_requests_info(NATIVE_WINDOW_FORMAT);
@@ -160,7 +144,7 @@
         .Times(4)
         .WillRepeatedly(Return(test_size));
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     unsigned int rc_width = render_window.driver_requests_info(NATIVE_WINDOW_DEFAULT_WIDTH);
     unsigned int rc_height = render_window.driver_requests_info(NATIVE_WINDOW_DEFAULT_HEIGHT);
@@ -177,7 +161,7 @@
 {
     using namespace testing;
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     EXPECT_EQ(0, render_window.driver_requests_info(NATIVE_WINDOW_TRANSFORM_HINT));
 }
@@ -185,7 +169,7 @@
 TEST_F(ServerRenderWindowTest, driver_unknown_inquiry)
 {
     using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     EXPECT_THROW({
         render_window.driver_requests_info(NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND);
@@ -194,7 +178,7 @@
 
 TEST_F(ServerRenderWindowTest, driver_swapinterval_request)
 {
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_device, mock_cache);
+    mga::ServerRenderWindow render_window(mock_display_device, mock_cache);
 
     EXPECT_CALL(*mock_display_device, sync_to_display(false))
         .Times(1);