Merge lp:~kdub/mir/interval0-signal into lp:~mir-team/mir/trunk

[Kevin DuBois]

Activate sending a "swapinterval" signal over IPC. Add client api for software clients to request different swapintervals. (eglSwapInterval is not glued together just yet). Currently only swapinterval of 0 or 1 is supported.

Activate sending a "swapinterval" signal over IPC. Add client api for software clients to request different swapintervals. (eglSwapInterval is not glued together just yet)
Currently only swapinterval of 0 or 1 is supported.

note that the actual path taken over ipc is via the surface parameters, there is no new protobuf message introduced to support the message.

tests/integration-tests/test_swapinterval.cpp tests from the client's request until the point that the request hits the compositor systems at mc::BufferStream

still in pre-review, dependent on anativewindow-external-refcount

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:758
http://jenkins.qa.ubuntu.com/job/mir-ci/751/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/937/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/819/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/236/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/435

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:758
http://jenkins.qa.ubuntu.com/job/mir-ci/772/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/971
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/853
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/10
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/10/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/451

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

review: Approve (continuous-integration)

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2013-06-06 08:36:17 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2013-06-19 18:36:29 +0000
@@ -293,6 +293,24 @@
  */
 MirSurfaceState mir_surface_get_state(MirSurface *surface);
 
+/**
+ * Set the swapinterval for mir_surface_swap_buffers. EGL users should use
+ * eglSwapInterval directly.
+ *   \param [in] surface  The surface to operate on
+ *   \param [in] interval The number of vblank signals that
+ *                        mir_surface_swap_buffers will wait for 
+ *   \return              A wait handle that can be passed to mir_wait_for
+ */
+MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surface, int interval);
+
+/**
+ * Query the swapinterval that the surface is operating with.
+ * The default interval is 1.
+ *   \param [in] surface  The surface to operate on
+ *   \return              The swapinterval value that the client is operating with
+ */
+int mir_surface_get_swapinterval(MirSurface* surface);
+
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/server/mir/compositor/buffer_allocation_strategy.h'
--- include/server/mir/compositor/buffer_allocation_strategy.h	2013-06-11 14:27:33 +0000
+++ include/server/mir/compositor/buffer_allocation_strategy.h	2013-06-19 18:36:29 +0000
@@ -45,7 +45,7 @@
 class BufferAllocationStrategy
 {
 public:
-    virtual std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(
+    virtual std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(BufferProperties const&,
         std::vector<std::shared_ptr<Buffer>>&, size_t, SwapperType) const = 0;
     virtual std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
         BufferProperties& actual_properties, BufferProperties const& requested_properties, SwapperType) const = 0;

=== modified file 'include/server/mir/compositor/buffer_stream_surfaces.h'
--- include/server/mir/compositor/buffer_stream_surfaces.h	2013-06-18 09:44:11 +0000
+++ include/server/mir/compositor/buffer_stream_surfaces.h	2013-06-19 18:36:29 +0000
@@ -47,6 +47,7 @@
 
     geometry::PixelFormat get_stream_pixel_format();
     geometry::Size stream_size();
+    void allow_framedropping(bool);
     void force_requests_to_complete();
 
 protected:

=== modified file 'include/server/mir/compositor/swapper_factory.h'
--- include/server/mir/compositor/swapper_factory.h	2013-06-11 15:05:27 +0000
+++ include/server/mir/compositor/swapper_factory.h	2013-06-19 18:36:29 +0000
@@ -38,14 +38,18 @@
         std::shared_ptr<GraphicBufferAllocator> const& gr_alloc,
         int number_of_buffers);
 
-    std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(
+    std::shared_ptr<BufferSwapper> create_swapper_reuse_buffers(BufferProperties const&,
         std::vector<std::shared_ptr<Buffer>>&, size_t, SwapperType) const;
     std::shared_ptr<BufferSwapper> create_swapper_new_buffers(
         BufferProperties& actual_properties, BufferProperties const& requested_properties, SwapperType) const;
 
 private:
+    void change_swapper_size(
+        std::vector<std::shared_ptr<Buffer>>&, size_t const, size_t, BufferProperties const&) const;
+
     std::shared_ptr<GraphicBufferAllocator> const gr_allocator;
-    int const number_of_buffers;
+    unsigned int const synchronous_number_of_buffers;
+    unsigned int const spin_number_of_buffers;
 };
 }
 }

=== modified file 'include/server/mir/graphics/gl_renderer.h'
--- include/server/mir/graphics/gl_renderer.h	2013-05-21 15:11:41 +0000
+++ include/server/mir/graphics/gl_renderer.h	2013-06-19 18:36:29 +0000
@@ -37,7 +37,6 @@
 
     /* From renderer */
     void render(std::function<void(std::shared_ptr<void> const&)> save_resource, Renderable& renderable);
-    void ensure_no_live_buffers_bound();
     void clear();
 
     ~GLRenderer() noexcept {}

=== modified file 'include/server/mir/graphics/renderer.h'
--- include/server/mir/graphics/renderer.h	2013-05-21 15:11:41 +0000
+++ include/server/mir/graphics/renderer.h	2013-06-19 18:36:29 +0000
@@ -36,7 +36,6 @@
 
     virtual void clear() = 0;
     virtual void render(std::function<void(std::shared_ptr<void> const&)> save_resource, Renderable& renderable) = 0;
-    virtual void ensure_no_live_buffers_bound() = 0;
 
 protected:
     Renderer() = default;

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-06-17 19:47:07 +0000
+++ include/server/mir/shell/surface.h	2013-06-19 18:36:29 +0000
@@ -87,6 +87,7 @@
 
     virtual void take_input_focus(std::shared_ptr<InputTargeter> const& targeter);
 
+    virtual void allow_framedropping(bool); 
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);

=== modified file 'include/server/mir/surfaces/buffer_stream.h'
--- include/server/mir/surfaces/buffer_stream.h	2013-06-13 10:40:42 +0000
+++ include/server/mir/surfaces/buffer_stream.h	2013-06-19 18:36:29 +0000
@@ -44,6 +44,7 @@
     virtual std::shared_ptr<surfaces::GraphicRegion> lock_back_buffer() = 0;
     virtual geometry::PixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;
+    virtual void allow_framedropping(bool) = 0;
     virtual void force_requests_to_complete() = 0;
 };
 

=== modified file 'include/server/mir/surfaces/surface.h'
--- include/server/mir/surfaces/surface.h	2013-06-12 15:36:31 +0000
+++ include/server/mir/surfaces/surface.h	2013-06-19 18:36:29 +0000
@@ -83,6 +83,8 @@
     bool supports_input() const;
     int client_input_fd() const;
     int server_input_fd() const;
+
+    void allow_framedropping(bool); 
 private:
     std::string surface_name;
     geometry::Point top_left_point;

=== added file 'include/shared/mir/graphics/android/mir_native_buffer.h'
--- include/shared/mir/graphics/android/mir_native_buffer.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/graphics/android/mir_native_buffer.h	2013-06-19 18:36:29 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_MIR_NATIVE_BUFFER_H_
+#define MIR_GRAPHICS_ANDROID_MIR_NATIVE_BUFFER_H_
+
+#include <system/window.h>
+#include <functional>
+#include <atomic>
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+struct MirNativeBuffer : public ANativeWindowBuffer
+{
+    MirNativeBuffer(std::function<void(MirNativeBuffer*)> free);
+    void driver_reference();
+    void driver_dereference();
+    void mir_dereference();
+
+private:
+    ~MirNativeBuffer();
+
+    std::function<void(MirNativeBuffer*)> free_fn;
+    std::atomic<bool> mir_reference;
+    std::atomic<int> driver_references;
+
+};
+
+struct MirNativeBufferDeleter
+{ 
+    void operator()(MirNativeBuffer* a)
+    {
+        a->mir_dereference();
+    }
+};
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_MIR_NATIVE_BUFFER_H_ */

=== modified file 'include/shared/mir_toolkit/common.h'
--- include/shared/mir_toolkit/common.h	2013-05-03 22:53:42 +0000
+++ include/shared/mir_toolkit/common.h	2013-06-19 18:36:29 +0000
@@ -35,6 +35,7 @@
 {
     mir_surface_attrib_type,
     mir_surface_attrib_state,
+    mir_surface_attrib_performance_hint,
     mir_surface_attrib_arraysize_
 } MirSurfaceAttrib;
 
@@ -63,6 +64,12 @@
     mir_surface_state_arraysize_
 } MirSurfaceState;
 
+typedef enum MirSurfacePerformanceHint
+{
+    mir_surface_hint_synchronous,
+    mir_surface_hint_drop_frames,
+    mir_surface_hint_arraysize_
+} MirSurfacePerformanceHint;
 /**@}*/
 
 #endif

=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2013-06-13 10:40:42 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2013-06-19 18:36:29 +0000
@@ -36,6 +36,8 @@
 
     MOCK_METHOD0(get_stream_pixel_format, geometry::PixelFormat());
     MOCK_METHOD0(stream_size, geometry::Size());
+    MOCK_METHOD0(force_client_completion, void());
+    MOCK_METHOD1(allow_framedropping, void(bool));
     MOCK_METHOD0(force_requests_to_complete, void());
 };
 }

=== modified file 'include/test/mir_test_doubles/mock_surface_renderer.h'
--- include/test/mir_test_doubles/mock_surface_renderer.h	2013-05-21 15:11:41 +0000
+++ include/test/mir_test_doubles/mock_surface_renderer.h	2013-06-19 18:36:29 +0000
@@ -32,8 +32,7 @@
 struct MockSurfaceRenderer : public graphics::Renderer
 {
     MOCK_METHOD2(render, void(std::function<void(std::shared_ptr<void> const&)>, graphics::Renderable&));
-    MOCK_METHOD0(ensure_no_live_buffers_bound, void());
-    MOCK_METHOD0(clear, void ());
+    MOCK_METHOD0(clear, void());
 
     ~MockSurfaceRenderer() noexcept {}
 };

=== modified file 'include/test/mir_test_doubles/mock_swapper_factory.h'
--- include/test/mir_test_doubles/mock_swapper_factory.h	2013-06-11 14:27:33 +0000
+++ include/test/mir_test_doubles/mock_swapper_factory.h	2013-06-19 18:36:29 +0000
@@ -33,8 +33,8 @@
 public:
     ~MockSwapperFactory() noexcept {}
 
-    MOCK_CONST_METHOD3(create_swapper_reuse_buffers,
-        std::shared_ptr<compositor::BufferSwapper>(
+    MOCK_CONST_METHOD4(create_swapper_reuse_buffers,
+        std::shared_ptr<compositor::BufferSwapper>(compositor::BufferProperties const&,
             std::vector<std::shared_ptr<compositor::Buffer>>&, size_t, compositor::SwapperType));
     MOCK_CONST_METHOD3(create_swapper_new_buffers,
         std::shared_ptr<compositor::BufferSwapper>(

=== modified file 'include/test/mir_test_doubles/null_buffer_stream.h'
--- include/test/mir_test_doubles/null_buffer_stream.h	2013-06-13 10:40:42 +0000
+++ include/test/mir_test_doubles/null_buffer_stream.h	2013-06-19 18:36:29 +0000
@@ -60,6 +60,10 @@
     {
     }
 
+    void allow_framedropping(bool)
+    {
+    }
+
     std::shared_ptr<compositor::Buffer> stub_buffer;
 };
 

=== modified file 'src/client/android/android_client_buffer.cpp'
--- src/client/android/android_client_buffer.cpp	2013-06-12 09:36:20 +0000
+++ src/client/android/android_client_buffer.cpp	2013-06-19 18:36:29 +0000
@@ -16,6 +16,7 @@
  * Authored by: Kevin DuBois<[e-mail]>
  */
 
+#include "mir/graphics/android/mir_native_buffer.h"
 #include "mir_toolkit/mir_client_library.h"
 #include "android_client_buffer.h"
 
@@ -23,6 +24,23 @@
 namespace mcl=mir::client;
 namespace mcla=mir::client::android;
 namespace geom=mir::geometry;
+namespace mga=mir::graphics::android;
+namespace
+{
+struct AndroidBufferHandleDeleter
+{
+    AndroidBufferHandleDeleter(std::shared_ptr<mcla::AndroidRegistrar> const& alloc_dev)
+        : buffer_registrar(alloc_dev)
+    {}
+
+    void operator()(mga::MirNativeBuffer* t)
+    {
+        buffer_registrar->unregister_buffer(t->handle);
+    }
+private:
+    std::shared_ptr<mcla::AndroidRegistrar> const buffer_registrar;
+};
+}
 
 mcla::AndroidClientBuffer::AndroidClientBuffer(std::shared_ptr<AndroidRegistrar> const& registrar,
                                                std::shared_ptr<MirBufferPackage> const& package,
@@ -30,20 +48,24 @@
  : creation_package(package),
    buffer_registrar(registrar),
    rect({{geom::X(0),geom::Y(0)}, size}),
-   buffer_pf(pf),
-   native_window_buffer(std::make_shared<ANativeWindowBuffer>())
+   buffer_pf(pf)
 {
-    creation_package = std::move(package);
+    AndroidBufferHandleDeleter del1(registrar);
+    auto tmp = new mga::MirNativeBuffer(del1);
+    mga::MirNativeBufferDeleter del;
+    native_window_buffer = std::shared_ptr<mga::MirNativeBuffer>(tmp, del);
     native_handle = std::shared_ptr<const native_handle_t> (convert_to_native_handle(creation_package));
 
-    buffer_registrar->register_buffer(native_handle.get());
+    try{ 
+        buffer_registrar->register_buffer(native_handle.get());
+    } catch (...)
+    {
+        //TODO: log failure
+    }
 
     pack_native_window_buffer();
 }
 
-static void incRef(android_native_base_t*)
-{
-}
 void mcla::AndroidClientBuffer::pack_native_window_buffer()
 {
     native_window_buffer->height = static_cast<int32_t>(rect.size.height.as_uint32_t());
@@ -51,15 +73,11 @@
     native_window_buffer->stride = creation_package->stride /
                                    geom::bytes_per_pixel(buffer_pf);
     native_window_buffer->usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;
-
     native_window_buffer->handle = native_handle.get();
-    native_window_buffer->common.incRef = &incRef;
-    native_window_buffer->common.decRef = &incRef;
 }
 
 mcla::AndroidClientBuffer::~AndroidClientBuffer() noexcept
 {
-    buffer_registrar->unregister_buffer(native_handle.get());
 }
 
 const native_handle_t* mcla::AndroidClientBuffer::convert_to_native_handle(const std::shared_ptr<MirBufferPackage>& package)

=== modified file 'src/client/mir_client_library.cpp'
--- src/client/mir_client_library.cpp	2013-06-06 08:36:17 +0000
+++ src/client/mir_client_library.cpp	2013-06-19 18:36:29 +0000
@@ -316,3 +316,35 @@
 
     return state;
 }
+
+MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surf, int interval)
+{
+    int hint = mir_surface_hint_synchronous;
+    switch (interval)
+    {
+        case 0:
+            hint = mir_surface_hint_drop_frames;
+        break;
+        case 1:
+            hint = mir_surface_hint_synchronous;
+        break;
+        default:
+        return NULL;
+    }
+
+    return surf ? surf->configure(mir_surface_attrib_performance_hint, hint) : NULL;
+}
+
+int mir_surface_get_swapinterval(MirSurface* surf)
+{
+    if (!surf)
+        return -1;
+
+    int s = surf->attrib(mir_surface_attrib_performance_hint);
+    if (s == mir_surface_hint_synchronous)
+        return 1;
+    if (s == mir_surface_hint_drop_frames)
+        return 0;
+
+    return -1;
+}

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2013-06-07 10:38:34 +0000
+++ src/client/mir_surface.cpp	2013-06-19 18:36:29 +0000
@@ -58,6 +58,7 @@
         attrib_cache[i] = -1;
     attrib_cache[mir_surface_attrib_type] = mir_surface_type_normal;
     attrib_cache[mir_surface_attrib_state] = mir_surface_state_unknown;
+    attrib_cache[mir_surface_attrib_performance_hint] = mir_surface_hint_synchronous;
 }
 
 MirSurface::~MirSurface()
@@ -269,6 +270,7 @@
         {
         case mir_surface_attrib_type:
         case mir_surface_attrib_state:
+        case mir_surface_attrib_performance_hint:
             if (configure_result.has_ivalue())
                 attrib_cache[a] = configure_result.ivalue();
             else

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2013-06-18 09:44:11 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2013-06-19 18:36:29 +0000
@@ -64,3 +64,7 @@
     buffer_bundle->force_requests_to_complete();
 }
 
+void mc::BufferStreamSurfaces::allow_framedropping(bool allow)
+{
+    buffer_bundle->allow_framedropping(allow);
+}

=== modified file 'src/server/compositor/rendering_operator.cpp'
--- src/server/compositor/rendering_operator.cpp	2013-05-22 09:56:40 +0000
+++ src/server/compositor/rendering_operator.cpp	2013-06-19 18:36:29 +0000
@@ -30,7 +30,6 @@
 
 mc::RenderingOperator::~RenderingOperator()
 {
-    renderer.ensure_no_live_buffers_bound();
 }
 
 void mc::RenderingOperator::operator()(graphics::Renderable& renderable)

=== modified file 'src/server/compositor/swapper_factory.cpp'
--- src/server/compositor/swapper_factory.cpp	2013-06-11 19:55:10 +0000
+++ src/server/compositor/swapper_factory.cpp	2013-06-19 18:36:29 +0000
@@ -36,7 +36,8 @@
         std::shared_ptr<GraphicBufferAllocator> const& gr_alloc,
         int number_of_buffers)
     : gr_allocator(gr_alloc),
-      number_of_buffers(number_of_buffers)
+      synchronous_number_of_buffers(number_of_buffers),
+      spin_number_of_buffers(3) //spin algorithm always takes 3 buffers
 {
 }
 
@@ -46,16 +47,42 @@
 {
 }
 
+void mc::SwapperFactory::change_swapper_size(
+    std::vector<std::shared_ptr<mc::Buffer>>& list,
+    size_t const desired_size, size_t current_size, 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(
-    std::vector<std::shared_ptr<Buffer>>& list, size_t buffer_num, SwapperType type) const
+    BufferProperties const& buffer_properties, std::vector<std::shared_ptr<Buffer>>& list,
+    size_t buffer_num, SwapperType type) const
 {
     if (type == mc::SwapperType::synchronous)
     {
-        return std::make_shared<mc::BufferSwapperMulti>(list, buffer_num); 
+        change_swapper_size(list, synchronous_number_of_buffers, buffer_num, buffer_properties);
+        return std::make_shared<mc::BufferSwapperMulti>(list, synchronous_number_of_buffers); 
     }
     else
     {
-        return std::make_shared<mc::BufferSwapperSpin>(list, buffer_num);
+        change_swapper_size(list, spin_number_of_buffers, buffer_num, buffer_properties);
+        return std::make_shared<mc::BufferSwapperSpin>(list, spin_number_of_buffers);
     }
 }
 
@@ -68,20 +95,19 @@
 
     if (type == mc::SwapperType::synchronous)
     {
-        for(auto i=0; i< number_of_buffers; i++)
+        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, number_of_buffers);
+        new_swapper = std::make_shared<mc::BufferSwapperMulti>(list, synchronous_number_of_buffers);
     }
     else
     {
-        int const async_buffer_count = 3; //async only can accept 3 buffers, so ignore constructor request
-        for(auto i=0; i < async_buffer_count; i++)
+        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, async_buffer_count);
+        new_swapper = std::make_shared<mc::BufferSwapperSpin>(list, spin_number_of_buffers);
     }
 
     actual_buffer_properties = BufferProperties{

=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2013-06-15 11:09:16 +0000
+++ src/server/compositor/switching_bundle.cpp	2013-06-19 18:36:29 +0000
@@ -92,9 +92,9 @@
     swapper->end_responsibility(list, size);
 
     if (allow_dropping)
-        swapper = swapper_factory->create_swapper_reuse_buffers(list, size, mc::SwapperType::framedropping); 
+        swapper = swapper_factory->create_swapper_reuse_buffers(bundle_properties, list, size, mc::SwapperType::framedropping);
     else
-        swapper = swapper_factory->create_swapper_reuse_buffers(list, size, mc::SwapperType::synchronous); 
+        swapper = swapper_factory->create_swapper_reuse_buffers(bundle_properties, list, size, mc::SwapperType::synchronous);
 
     cv.notify_all();
 }

=== modified file 'src/server/graphics/android/android_alloc_adaptor.cpp'
--- src/server/graphics/android/android_alloc_adaptor.cpp	2013-05-22 15:33:21 +0000
+++ src/server/graphics/android/android_alloc_adaptor.cpp	2013-06-19 18:36:29 +0000
@@ -17,6 +17,7 @@
  *   Kevin DuBois <[e-mail]>
  */
 
+#include "mir/graphics/android/mir_native_buffer.h"
 #include "android_alloc_adaptor.h"
 #include "android_format_conversion-inl.h"
 
@@ -35,18 +36,13 @@
         : alloc_device(alloc_dev)
     {}
 
-    void operator()(ANativeWindowBuffer* t)
+    void operator()(mga::MirNativeBuffer* t)
     {
         alloc_device->free(alloc_device.get(), t->handle);
-        delete t;
     }
 private:
     std::shared_ptr<alloc_device_t> const alloc_device;
 };
-
-static void incRef(android_native_base_t*)
-{
-}
 }
 
 mga::AndroidAllocAdaptor::AndroidAllocAdaptor(const std::shared_ptr<struct alloc_device_t>& alloc_device)
@@ -71,8 +67,11 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("buffer allocation failed\n"));
     }
 
-    /* pack ANativeWindow buffer for the handle */
-    auto buffer =  new ANativeWindowBuffer;
+    AndroidBufferHandleDeleter del1(alloc_dev);
+    auto tmp = new mga::MirNativeBuffer(del1);
+    mga::MirNativeBufferDeleter del;
+    std::shared_ptr<mga::MirNativeBuffer> buffer(tmp, del);
+
     buffer->width = width;
     buffer->height = height;
     buffer->stride = stride;
@@ -80,17 +79,7 @@
     buffer->format = format;
     buffer->usage = usage_flag;
 
-    /* we don't use these for refcounting buffers. however, drivers still expect to be
-       able to call them */
-    buffer->common.incRef = &incRef;
-    buffer->common.decRef = &incRef;
-    buffer->common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
-    buffer->common.version = sizeof(ANativeWindowBuffer);
-
-    AndroidBufferHandleDeleter del(alloc_dev);
-    auto handle = std::shared_ptr<ANativeWindowBuffer>(buffer, del);
-
-    return handle;
+    return buffer;
 }
 
 int mga::AndroidAllocAdaptor::convert_to_android_usage(BufferUsage usage)

=== modified file 'src/server/graphics/gl_renderer.cpp'
--- src/server/graphics/gl_renderer.cpp	2013-05-21 15:11:41 +0000
+++ src/server/graphics/gl_renderer.cpp	2013-06-19 18:36:29 +0000
@@ -248,14 +248,6 @@
     glDisableVertexAttribArray(resources.position_attr_loc);
 }
 
-void mg::GLRenderer::ensure_no_live_buffers_bound()
-{
-    /* before the system can delete buffers that back OES_EGL_image textures, it
-       must make sure that none of these textures are bound in the GLContext*/
-    static int emptytexture;
-    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,1,1,0,GL_RGBA,GL_UNSIGNED_BYTE, &emptytexture);
-}
-
 void mg::GLRenderer::clear()
 {
     glClear(GL_COLOR_BUFFER_BIT);

=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-06-17 19:47:07 +0000
+++ src/server/shell/surface.cpp	2013-06-19 18:36:29 +0000
@@ -185,6 +185,14 @@
     }
 }
 
+void msh::Surface::allow_framedropping(bool allow)
+{
+    if (auto const& s = surface.lock())
+    {
+        s->allow_framedropping(allow);
+    }
+}
+ 
 std::shared_ptr<mc::Buffer> msh::Surface::client_buffer() const
 {
     if (auto const& s = surface.lock())
@@ -236,7 +244,7 @@
 int msh::Surface::configure(MirSurfaceAttrib attrib, int value)
 {
     int result = 0;
-
+    bool allow_dropping = false;
     /*
      * TODO: In future, query the shell implementation for the subset of
      *       attributes/types it implements.
@@ -255,6 +263,11 @@
             BOOST_THROW_EXCEPTION(std::logic_error("Invalid surface state."));
         result = state();
         break;
+    case mir_surface_attrib_performance_hint:
+        allow_dropping = (value == mir_surface_hint_drop_frames);
+        allow_framedropping(allow_dropping);
+        result = value;
+        break;
     default:
         BOOST_THROW_EXCEPTION(std::logic_error("Invalid surface "
                                                "attribute."));

=== modified file 'src/server/surfaces/surface.cpp'
--- src/server/surfaces/surface.cpp	2013-06-13 10:40:42 +0000
+++ src/server/surfaces/surface.cpp	2013-06-19 18:36:29 +0000
@@ -177,6 +177,11 @@
     return client_buffer_resource;
 }
 
+void ms::Surface::allow_framedropping(bool allow)
+{
+    buffer_stream->allow_framedropping(allow);
+}
+
 void ms::Surface::flag_for_render()
 {
     buffer_is_valid = true;

=== modified file 'src/shared/graphics/android/CMakeLists.txt'
--- src/shared/graphics/android/CMakeLists.txt	2013-03-29 22:30:35 +0000
+++ src/shared/graphics/android/CMakeLists.txt	2013-06-19 18:36:29 +0000
@@ -2,6 +2,7 @@
   mirsharedandroid STATIC
 
   mir_native_window.cpp
+  mir_native_buffer.cpp
   syncfence.cpp
 )
 

=== added file 'src/shared/graphics/android/mir_native_buffer.cpp'
--- src/shared/graphics/android/mir_native_buffer.cpp	1970-01-01 00:00:00 +0000
+++ src/shared/graphics/android/mir_native_buffer.cpp	2013-06-19 18:36:29 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "mir/graphics/android/mir_native_buffer.h"
+
+namespace mga=mir::graphics::android;
+
+namespace
+{
+static void incref_hook(struct android_native_base_t* base)
+{
+    auto buffer = reinterpret_cast<mga::MirNativeBuffer*>(base);
+    buffer->driver_reference();
+}
+static void decref_hook(struct android_native_base_t* base)
+{
+    auto buffer = reinterpret_cast<mga::MirNativeBuffer*>(base);
+    buffer->driver_dereference();
+}
+}
+
+mga::MirNativeBuffer::MirNativeBuffer(std::function<void(MirNativeBuffer*)> free)
+    : free_fn(free),
+      mir_reference(true),
+      driver_references(0)
+{
+    common.incRef = incref_hook;
+    common.decRef = decref_hook;
+}
+
+
+void mga::MirNativeBuffer::driver_reference()
+{
+    driver_references++;
+}
+
+void mga::MirNativeBuffer::driver_dereference()
+{
+    driver_references--;
+    if ((!mir_reference) && (driver_references ==0))
+    {
+        delete this;
+    }
+}
+
+void mga::MirNativeBuffer::mir_dereference()
+{
+    mir_reference = false;
+    if ((!mir_reference) && (driver_references ==0))
+    {
+        delete this;
+    }
+}
+
+mga::MirNativeBuffer::~MirNativeBuffer()
+{
+    free_fn(this);
+}

=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2013-06-06 08:36:17 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2013-06-19 18:36:29 +0000
@@ -51,9 +51,6 @@
          */
         std::this_thread::yield();
     }
-    void ensure_no_live_buffers_bound()
-    {
-    }
 
     void clear() {}
 };

=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2013-05-30 03:50:54 +0000
+++ tests/integration-tests/CMakeLists.txt	2013-06-19 18:36:29 +0000
@@ -7,6 +7,7 @@
   test_display_info.cpp
   test_display_server_main_loop_events.cpp
   test_surface_first_frame_sync.cpp
+  test_swapinterval.cpp
 )
 
 add_subdirectory(client/)

=== modified file 'tests/integration-tests/test_surface_first_frame_sync.cpp'
--- tests/integration-tests/test_surface_first_frame_sync.cpp	2013-06-12 10:27:50 +0000
+++ tests/integration-tests/test_surface_first_frame_sync.cpp	2013-06-19 18:36:29 +0000
@@ -96,8 +96,6 @@
         while (write(render_operations_fd, "a", 1) != 1) continue;
     }
 
-    void ensure_no_live_buffers_bound() {}
-
 private:
     int render_operations_fd;
 };

=== added file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2013-06-19 18:36:29 +0000
@@ -0,0 +1,226 @@
+/*
+ * 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]>
+ */
+
+#include "mir/geometry/rectangle.h"
+#include "mir/graphics/display.h"
+#include "mir/graphics/display_buffer.h"
+#include "mir/graphics/renderer.h"
+#include "mir/graphics/renderable.h"
+#include "mir/compositor/compositor.h"
+#include "mir/compositor/compositing_strategy.h"
+#include "mir/compositor/renderables.h"
+#include "mir/surfaces/buffer_stream.h"
+#include "mir/surfaces/buffer_stream_factory.h"
+
+#include "mir_test_framework/display_server_test_fixture.h"
+#include "mir_test_doubles/stub_buffer.h"
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include <gtest/gtest.h>
+
+#include <thread>
+#include <unistd.h>
+#include <fcntl.h>
+
+namespace geom = mir::geometry;
+namespace mg = mir::graphics;
+namespace mc = mir::compositor;
+namespace mtf = mir_test_framework;
+namespace ms = mir::surfaces;
+namespace mtd = mir::test::doubles;
+
+namespace
+{
+char const* const mir_test_socket = mtf::test_socket_file().c_str();
+
+class CountingBufferStream : public ms::BufferStream
+{
+public:
+    CountingBufferStream(int render_operations_fd)
+     : render_operations_fd(render_operations_fd)
+    {
+    }
+
+    std::shared_ptr<mc::Buffer> secure_client_buffer() { return std::make_shared<mtd::StubBuffer>(); }
+    std::shared_ptr<ms::GraphicRegion> lock_back_buffer() { return std::make_shared<mtd::StubBuffer>(); }
+    geom::PixelFormat get_stream_pixel_format() { return geom::PixelFormat::abgr_8888; }
+    geom::Size stream_size() { return geom::Size{}; }
+    void force_requests_to_complete() {}
+    void allow_framedropping(bool)
+    {
+        while (write(render_operations_fd, "a", 1) != 1) continue;
+    }
+
+private:
+    int render_operations_fd; 
+};
+
+class StubStreamFactory : public ms::BufferStreamFactory
+{
+public:
+    StubStreamFactory(int render_operations_fd)
+     : render_operations_fd(render_operations_fd)
+    {
+    }
+
+    std::shared_ptr<ms::BufferStream> create_buffer_stream(mc::BufferProperties const&)
+    {
+        return std::make_shared<CountingBufferStream>(render_operations_fd);
+    }
+private:
+    int render_operations_fd; 
+};
+
+}
+
+using SwapIntervalSignalTest = BespokeDisplayServerTestFixture;
+TEST_F(SwapIntervalSignalTest, swapinterval_test)
+{
+    static std::string const swapinterval_set{"swapinterval_set_952f3f10.tmp"};
+    static std::string const do_client_finish{"do_client_finish_952f3f10.tmp"};
+
+    std::remove(swapinterval_set.c_str());
+    std::remove(do_client_finish.c_str());
+
+    struct ServerConfig : TestingServerConfiguration
+    {
+        ServerConfig()
+        {
+            if (pipe(rendering_ops_pipe) != 0)
+            {
+                BOOST_THROW_EXCEPTION(
+                    std::runtime_error("Failed to create pipe"));
+            }
+
+            if (fcntl(rendering_ops_pipe[0], F_SETFL, O_NONBLOCK) != 0)
+            {
+                BOOST_THROW_EXCEPTION(
+                    std::runtime_error("Failed to make the read end of the pipe non-blocking"));
+            }
+        }
+
+        ~ServerConfig()
+        {
+            if (rendering_ops_pipe[0] >= 0)
+                close(rendering_ops_pipe[0]);
+            if (rendering_ops_pipe[1] >= 0)
+                close(rendering_ops_pipe[1]);
+        }
+
+        std::shared_ptr<ms::BufferStreamFactory> the_buffer_stream_factory() override
+        {
+            if (!stub_stream_factory)
+                stub_stream_factory = std::make_shared<StubStreamFactory>(rendering_ops_pipe[1]);
+            return stub_stream_factory;
+        }
+
+        int num_of_swapinterval_commands()
+        {
+            char c;
+            int ops{0};
+
+            while (read(rendering_ops_pipe[0], &c, 1) == 1)
+                ops++;
+
+            return ops;
+        }
+
+        int rendering_ops_pipe[2];
+        std::shared_ptr<StubStreamFactory> stub_stream_factory;
+    } server_config;
+
+    launch_server_process(server_config);
+
+    struct ClientConfig : TestingClientConfiguration
+    {
+        ClientConfig(std::string const& swapinterval_set,
+                     std::string const& do_client_finish)
+            : swapinterval_set{swapinterval_set},
+              do_client_finish{do_client_finish}
+        {
+        }
+
+        static void surface_callback(MirSurface*, void*)
+        {
+        }
+
+        void exec()
+        {
+            MirSurfaceParameters request_params =
+            {
+                __PRETTY_FUNCTION__,
+                640, 480,
+                mir_pixel_format_abgr_8888,
+                mir_buffer_usage_hardware
+            };
+
+            MirConnection* connection = mir_connect_sync(mir_test_socket, "testapp");
+            MirSurface* surface = mir_connection_create_surface_sync(connection, &request_params);
+
+            //1 is the default swapinterval
+            EXPECT_EQ(1, mir_surface_get_swapinterval(surface));
+
+            mir_wait_for(mir_surface_set_swapinterval(surface, 0));
+            EXPECT_EQ(0, mir_surface_get_swapinterval(surface));
+
+            mir_wait_for(mir_surface_set_swapinterval(surface, 1));
+            EXPECT_EQ(1, mir_surface_get_swapinterval(surface));
+
+            //swapinterval 2 not supported
+            EXPECT_EQ(NULL, mir_surface_set_swapinterval(surface, 2));
+            EXPECT_EQ(1, mir_surface_get_swapinterval(surface)); 
+
+            set_flag(swapinterval_set);
+            wait_for(do_client_finish);
+
+            mir_surface_release_sync(surface);
+            mir_connection_release(connection);
+        }
+
+        /* TODO: Extract this flag mechanism and make it reusable */
+        void set_flag(std::string const& flag_file)
+        {
+            close(open(flag_file.c_str(), O_CREAT, S_IWUSR | S_IRUSR));
+        }
+
+        void wait_for(std::string const& flag_file)
+        {
+            int fd = -1;
+            while ((fd = open(flag_file.c_str(), O_RDONLY, S_IWUSR | S_IRUSR)) == -1)
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+            close(fd);
+        }
+
+        std::string const swapinterval_set;
+        std::string const do_client_finish;
+    } client_config{swapinterval_set, do_client_finish};
+
+    launch_client_process(client_config);
+
+    run_in_test_process([&]
+    {
+        client_config.wait_for(swapinterval_set);
+
+        EXPECT_EQ(2, server_config.num_of_swapinterval_commands());
+
+        client_config.set_flag(do_client_finish);
+    });
+}

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-06-12 10:27:50 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-06-19 18:36:29 +0000
@@ -141,10 +141,6 @@
         r.graphic_region();
     }
 
-    void ensure_no_live_buffers_bound()
-    {
-    }
-
     void clear() {}
 };
 

=== modified file 'tests/unit-tests/client/android/test_client_android_buffer.cpp'
--- tests/unit-tests/client/android/test_client_android_buffer.cpp	2013-06-12 09:36:20 +0000
+++ tests/unit-tests/client/android/test_client_android_buffer.cpp	2013-06-19 18:36:29 +0000
@@ -335,6 +335,6 @@
     ASSERT_NE(nullptr, native_handle->common.incRef);
     ASSERT_NE(nullptr, native_handle->common.decRef);
 
-    native_handle->common.incRef(NULL);
-    native_handle->common.decRef(NULL);
+    native_handle->common.incRef(&native_handle->common);
+    native_handle->common.decRef(&native_handle->common);
 }

=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2013-06-17 15:55:04 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2013-06-19 18:36:29 +0000
@@ -122,3 +122,12 @@
 
     buffer_stream.secure_client_buffer();
 }
+
+TEST_F(BufferStreamTest, allow_framedropping_command)
+{
+    EXPECT_CALL(*mock_bundle, allow_framedropping(true))
+        .Times(1);
+
+    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
+    buffer_stream.allow_framedropping(true);
+}

=== modified file 'tests/unit-tests/compositor/test_rendering_operator.cpp'
--- tests/unit-tests/compositor/test_rendering_operator.cpp	2013-05-22 09:56:40 +0000
+++ tests/unit-tests/compositor/test_rendering_operator.cpp	2013-06-19 18:36:29 +0000
@@ -45,9 +45,6 @@
 
     void clear() {}
 
-    void ensure_no_live_buffers_bound()
-    {
-    }
     void render(std::function<void(std::shared_ptr<void> const&)> save_resource, mg::Renderable&)
     {
         std::shared_ptr<void> tmp;
@@ -81,7 +78,6 @@
 {
 public:
     MOCK_METHOD2(render, void(std::function<void(std::shared_ptr<void> const&)>, mg::Renderable&));
-    MOCK_METHOD0(ensure_no_live_buffers_bound, void());
     MOCK_METHOD0(clear, void ());
 
     ~MockRenderer() noexcept {}
@@ -122,11 +118,3 @@
     EXPECT_EQ(use_count_before1, stub_renderer.resource1.use_count());
     EXPECT_EQ(use_count_before2, stub_renderer.resource2.use_count());
 }
-
-TEST(RenderingOperator, render_operator_ensures_no_live_texture_bound)
-{
-    MockRenderer mock_renderer;
-    EXPECT_CALL(mock_renderer, ensure_no_live_buffers_bound())
-        .Times(1);
-    mc::RenderingOperator rendering_operator(mock_renderer, [](std::shared_ptr<void> const&) {});
-}

=== modified file 'tests/unit-tests/compositor/test_swapper_factory.cpp'
--- tests/unit-tests/compositor/test_swapper_factory.cpp	2013-06-11 19:55:10 +0000
+++ tests/unit-tests/compositor/test_swapper_factory.cpp	2013-06-19 18:36:29 +0000
@@ -147,6 +147,7 @@
 {
     using namespace testing;
 
+    mc::BufferProperties properties;
     std::vector<std::shared_ptr<mc::Buffer>> list {};
     size_t size = 3;
 
@@ -154,19 +155,66 @@
         .Times(0);
 
     mc::SwapperFactory strategy(mock_buffer_allocator);
-    auto swapper = strategy.create_swapper_reuse_buffers(list, size, mc::SwapperType::framedropping);
+    auto swapper = strategy.create_swapper_reuse_buffers(properties, list, size, mc::SwapperType::framedropping);
 }
 
 TEST_F(SwapperFactoryTest, create_sync_reuse)
 {
     using namespace testing;
 
+    mc::BufferProperties properties;
     std::vector<std::shared_ptr<mc::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<mc::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<mc::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);
-    auto swapper = strategy.create_swapper_reuse_buffers(list, size, mc::SwapperType::synchronous);
+
+    size_t size = 2;
+    std::vector<std::shared_ptr<mc::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-06-13 08:59:25 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2013-06-19 18:36:29 +0000
@@ -90,7 +90,7 @@
         .WillOnce(Return(stub_buffer));
     EXPECT_CALL(*mock_secondary_swapper, client_release(stub_buffer))
         .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_))
+    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,_))
         .Times(1)
         .WillOnce(Return(mock_secondary_swapper));
 
@@ -126,7 +126,7 @@
         .WillOnce(Return(stub_buffer));
     EXPECT_CALL(*mock_secondary_swapper, compositor_release(stub_buffer))
         .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_))
+    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,_))
         .Times(1)
         .WillOnce(Return(mock_secondary_swapper));
 
@@ -147,7 +147,7 @@
         .Times(1);
     EXPECT_CALL(*mock_default_swapper, end_responsibility(_,_))
         .Times(1);
-    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,mc::SwapperType::framedropping))
+    EXPECT_CALL(*mock_swapper_factory, create_swapper_reuse_buffers(_,_,_,mc::SwapperType::framedropping))
         .Times(1)
         .WillOnce(Return(mock_secondary_swapper));
 

=== modified file 'tests/unit-tests/graphics/android/CMakeLists.txt'
--- tests/unit-tests/graphics/android/CMakeLists.txt	2013-05-21 20:58:15 +0000
+++ tests/unit-tests/graphics/android/CMakeLists.txt	2013-06-19 18:36:29 +0000
@@ -22,6 +22,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_pixel_format.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_platform.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_interpreter_buffer_cache.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_external_refcount.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== modified file 'tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp'
--- tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2013-05-21 21:43:25 +0000
+++ tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2013-06-19 18:36:29 +0000
@@ -217,20 +217,13 @@
     EXPECT_EQ(fb_usage_flags, handle->usage);
 }
 
-TEST_F(AdaptorICSTest, handle_has_reffable_incref)
+TEST_F(AdaptorICSTest, handle_has_strong_reference_for_c_drivers)
 {
-    struct android_native_base_t *native_base = nullptr;
     auto handle = alloc_adaptor->alloc_buffer(size, pf, usage);
     ASSERT_NE(nullptr, handle->common.incRef);
-    handle->common.incRef(native_base);
-}
-
-TEST_F(AdaptorICSTest, handle_has_reffable_decref)
-{
-    struct android_native_base_t *native_base = nullptr;
-    auto handle = alloc_adaptor->alloc_buffer(size, pf, usage);
     ASSERT_NE(nullptr, handle->common.decRef);
-    handle->common.decRef(native_base);
+    handle->common.incRef(&handle->common);
+    handle->common.decRef(&handle->common);
 }
 
 TEST_F(AdaptorICSTest, handle_has_right_magic)

=== added file 'tests/unit-tests/graphics/android/test_external_refcount.cpp'
--- tests/unit-tests/graphics/android/test_external_refcount.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_external_refcount.cpp	2013-06-19 18:36:29 +0000
@@ -0,0 +1,70 @@
+/*
+ * 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]>
+ */
+
+#include "mir/graphics/android/mir_native_buffer.h"
+#include <memory>
+#include <gtest/gtest.h>
+
+namespace mga=mir::graphics::android;
+
+TEST(AndroidRefcount, driver_hooks)
+{
+    int call_count = 0;
+    mga::MirNativeBuffer* driver_reference = nullptr;
+    {
+        auto tmp = new mga::MirNativeBuffer(
+            [&](mga::MirNativeBuffer*)
+            {
+                call_count++;
+            });
+        mga::MirNativeBufferDeleter del;
+        std::shared_ptr<mga::MirNativeBuffer> buffer(tmp, del);
+        driver_reference = buffer.get();
+        driver_reference->common.incRef(&driver_reference->common);
+        //Mir loses its reference
+    }
+
+    EXPECT_EQ(0, call_count);
+    driver_reference->common.decRef(&driver_reference->common);
+    EXPECT_EQ(1, call_count);
+}
+
+TEST(AndroidRefcount, driver_hooks_mir_ref)
+{
+    int call_count = 0;
+    {
+        std::shared_ptr<mga::MirNativeBuffer> mir_reference;
+        mga::MirNativeBuffer* driver_reference = nullptr;
+        {
+            auto tmp = new mga::MirNativeBuffer(
+                [&](mga::MirNativeBuffer*)
+                {
+                    call_count++;
+                });
+            mga::MirNativeBufferDeleter del;
+            mir_reference = std::shared_ptr<mga::MirNativeBuffer>(tmp, del);
+            driver_reference = mir_reference.get();
+            driver_reference->common.incRef(&driver_reference->common);
+        }
+
+        //driver loses its reference
+        driver_reference->common.decRef(&driver_reference->common);
+        EXPECT_EQ(0, call_count);
+    }
+    EXPECT_EQ(1, call_count);
+}

=== modified file 'tests/unit-tests/graphics/test_gl_renderer.cpp'
--- tests/unit-tests/graphics/test_gl_renderer.cpp	2013-06-12 15:36:31 +0000
+++ tests/unit-tests/graphics/test_gl_renderer.cpp	2013-06-19 18:36:29 +0000
@@ -349,13 +349,3 @@
     auto result = std::find(saved_resources.begin(), saved_resources.end(), gr_ptr);
     EXPECT_NE(saved_resources.end(), result);
 }
-
-TEST_F(GLRenderer, TestRenderEnsureNoBind)
-{
-    using namespace std::placeholders;
-
-    mtd::MockRenderable rd;
-    EXPECT_CALL(mock_gl, glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,1,1,0,GL_RGBA,GL_UNSIGNED_BYTE,_));
-
-    renderer->ensure_no_live_buffers_bound();
-}

=== modified file 'tests/unit-tests/surfaces/test_surface.cpp'
--- tests/unit-tests/surfaces/test_surface.cpp	2013-06-13 10:40:42 +0000
+++ tests/unit-tests/surfaces/test_surface.cpp	2013-06-19 18:36:29 +0000
@@ -420,6 +420,18 @@
     surf.force_requests_to_complete();
 }
 
+TEST_F(SurfaceCreation, test_surface_allow_framedropping)
+{
+    using namespace testing;
+
+    EXPECT_CALL(*mock_buffer_stream, allow_framedropping(true))
+        .Times(1);
+
+    ms::Surface surf{surface_name, geom::Point(), mock_buffer_stream,
+        std::shared_ptr<mi::InputChannel>(), mock_change_cb};
+    surf.allow_framedropping(true);
+}
+
 TEST_F(SurfaceCreation, input_fds)
 {
     using namespace testing;