Merge lp:~kdub/mir/usage-deprecation-nested into lp:mir

[Kevin DuBois]

platform: add deprecation path for mg::BufferUsage for the nested platform. This adds a path to create a software buffer, and uses the extensions to create the hardware buffers.

platform: add deprecation path for mg::BufferUsage for the nested platform. This adds a path to create a software buffer, and uses the extensions to create the hardware buffers.

[Mir CI Bot (mir-ci-bot)]

PASSED: Continuous integration, rev:3918
https://mir-jenkins.ubuntu.com/job/mir-ci/2645/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/3435
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/3502
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/3494
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/3494
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/3494
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/3464/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3464/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/3464/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/3464/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3464/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/3464
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/3464/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2645/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Looks reasonable, but when I try to launch mir_demo_client inside a nested mir server it segfaults.

Host server:
    $ bin/mir_demo_server --x11-displays 800x600 --launch qterminal\&qterminal

Nested server (in first qtermial window):
    $ bin/mir_demo_server --host $XDG_RUNTIME_DIR/mir_socket --file mir_socket

Client (in second qterminal window):
    $ bin/mir_demo_client_egltriangle -m mir_socket

I checked this works with 0.25

review: Needs Fixing

[Kevin DuBois (kdub)]

thanks for noticing, working on fixing. Was a bit overzealous in removing the old code before the whole new system is in place.

[lp:~kdub/mir/usage-deprecation-nested]

3919. By Kevin DuBois on 2017-01-12

add back path that allows for server-selected hardware allocation request

3920. By Kevin DuBois on 2017-01-12

merge in mir

3921. By Kevin DuBois on 2017-01-12

diff reduction

[Alan Griffiths (alan-griffiths)]

> thanks for noticing, working on fixing. Was a bit overzealous in removing the
> old code before the whole new system is in place.

Fixed. Thanks - I'll just have another look over the code

review: Abstain

[Alan Griffiths (alan-griffiths)]

Looks good. (Would like CI to compile it before landing, just in case there's a weird compiler out there.)

review: Approve

[Cemil Azizoglu (cemil-azizoglu)]

yeap lgtm

review: Approve

=== modified file 'src/server/graphics/nested/buffer.cpp'
--- src/server/graphics/nested/buffer.cpp	2016-12-14 06:27:05 +0000
+++ src/server/graphics/nested/buffer.cpp	2017-01-12 13:57:10 +0000
@@ -19,6 +19,7 @@
 #include "mir/renderer/sw/pixel_source.h"
 #include "mir/renderer/gl/texture_source.h"
 #include "mir/graphics/egl_extensions.h"
+#include "mir/graphics/buffer_ipc_message.h"
 #include "mir_toolkit/mir_buffer.h"
 #include "host_connection.h"
 #include "buffer.h"
@@ -179,6 +180,25 @@
 {
 }
 
+mgn::Buffer::Buffer(
+    std::shared_ptr<HostConnection> const& connection,
+    geom::Size size, uint32_t native_format, uint32_t native_flags) :
+    connection(connection),
+    buffer(connection->create_buffer(size, native_format, native_flags)),
+    native_base(std::make_shared<TextureAccess>(*this, buffer, connection))
+{
+}
+
+mgn::Buffer::Buffer(
+    std::shared_ptr<HostConnection> const& connection,
+    geom::Size size,
+    MirPixelFormat format) :
+    connection(connection),
+    buffer(connection->create_buffer(size, format)),
+    native_base(std::make_shared<PixelAndTextureAccess>(*this, buffer, connection))
+{
+}
+
 std::shared_ptr<mg::NativeBuffer> mgn::Buffer::native_buffer_handle() const
 {
     return buffer;

=== modified file 'src/server/graphics/nested/buffer.h'
--- src/server/graphics/nested/buffer.h	2016-10-31 02:37:31 +0000
+++ src/server/graphics/nested/buffer.h	2017-01-12 13:57:10 +0000
@@ -40,6 +40,12 @@
     Buffer(
         std::shared_ptr<HostConnection> const& connection,
         BufferProperties const& properties);
+    Buffer(
+        std::shared_ptr<HostConnection> const& connection,
+        geometry::Size size, MirPixelFormat pf);
+    Buffer(
+        std::shared_ptr<HostConnection> const& connection,
+        geometry::Size size, unsigned int native_format, unsigned int native_flags);
 
     std::shared_ptr<graphics::NativeBuffer> native_buffer_handle() const override;
     geometry::Size size() const override;

=== modified file 'src/server/graphics/nested/host_connection.h'
--- src/server/graphics/nested/host_connection.h	2016-12-09 02:54:31 +0000
+++ src/server/graphics/nested/host_connection.h	2017-01-12 13:57:10 +0000
@@ -77,6 +77,8 @@
     virtual void set_input_event_callback(std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> const& cb) = 0;
     virtual void emit_input_event(MirEvent const& event, mir::geometry::Rectangle const& source_frame) = 0;
     virtual std::shared_ptr<NativeBuffer> create_buffer(graphics::BufferProperties const&) = 0;
+    virtual std::shared_ptr<NativeBuffer> create_buffer(mir::geometry::Size, MirPixelFormat format) = 0;
+    virtual std::shared_ptr<NativeBuffer> create_buffer(geometry::Size, uint32_t format, uint32_t flags) = 0;
     virtual bool supports_passthrough() = 0;
 
 protected:

=== modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	2017-01-11 20:17:22 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2017-01-12 13:57:10 +0000
@@ -31,10 +31,13 @@
 #include "mir_toolkit/mir_buffer_private.h"
 #include "mir_toolkit/mir_presentation_chain.h"
 #include "mir_toolkit/extensions/fenced_buffers.h"
+#include "mir_toolkit/extensions/android_buffer.h"
+#include "mir_toolkit/extensions/gbm_buffer.h"
 #include "mir/raii.h"
 #include "mir/graphics/platform_operation_message.h"
 #include "mir/graphics/cursor_image.h"
 #include "mir/graphics/buffer.h"
+#include "mir/graphics/buffer_ipc_message.h"
 #include "mir/input/device.h"
 #include "mir/input/device_capability.h"
 #include "mir/input/mir_pointer_configuration.h"
@@ -568,6 +571,60 @@
             BOOST_THROW_EXCEPTION(std::runtime_error("could not allocate MirBuffer"));
         }
     }
+
+    HostBuffer(MirConnection* mir_connection, geom::Size size, MirPixelFormat format) :
+        fence_extensions(mir_extension_fenced_buffers_v1(mir_connection))
+    {
+        mir_connection_allocate_buffer(
+            mir_connection,
+            size.width.as_int(),
+            size.height.as_int(),
+            format,
+            mir_buffer_usage_software,
+            buffer_available, this);
+        std::unique_lock<std::mutex> lk(mut);
+        cv.wait(lk, [&]{ return handle; });
+        if (!mir_buffer_is_valid(handle))
+        {
+            mir_buffer_release(handle);
+            BOOST_THROW_EXCEPTION(std::runtime_error("could not allocate MirBuffer"));
+        }
+    }
+
+    HostBuffer(MirConnection* mir_connection,
+        MirExtensionGbmBufferV1 const* ext,
+        geom::Size size, unsigned int native_pf, unsigned int native_flags) :
+        fence_extensions(mir_extension_fenced_buffers_v1(mir_connection))
+    {
+        ext->allocate_buffer_gbm(
+            mir_connection, size.width.as_int(), size.height.as_int(), native_pf, native_flags,
+            buffer_available, this);
+        std::unique_lock<std::mutex> lk(mut);
+        cv.wait(lk, [&]{ return handle; });
+        if (!mir_buffer_is_valid(handle))
+        {
+            mir_buffer_release(handle);
+            BOOST_THROW_EXCEPTION(std::runtime_error("could not allocate MirBuffer"));
+        }
+    }
+
+    HostBuffer(MirConnection* mir_connection,
+        MirExtensionAndroidBufferV1 const* ext,
+        geom::Size size, unsigned int native_pf, unsigned int native_flags) :
+        fence_extensions(mir_extension_fenced_buffers_v1(mir_connection))
+    {
+        ext->allocate_buffer_android(
+            mir_connection, size.width.as_int(), size.height.as_int(), native_pf, native_flags,
+            buffer_available, this);
+        std::unique_lock<std::mutex> lk(mut);
+        cv.wait(lk, [&]{ return handle; });
+        if (!mir_buffer_is_valid(handle))
+        {
+            mir_buffer_release(handle);
+            BOOST_THROW_EXCEPTION(std::runtime_error("could not allocate MirBuffer"));
+        }
+    }
+
     ~HostBuffer()
     {
         mir_buffer_release(handle);
@@ -707,6 +764,28 @@
     return std::make_shared<HostBuffer>(mir_connection, properties);
 }
 
+std::shared_ptr<mgn::NativeBuffer> mgn::MirClientHostConnection::create_buffer(
+    geom::Size size, MirPixelFormat format)
+{
+    return std::make_shared<HostBuffer>(mir_connection, size, format);
+}
+
+std::shared_ptr<mgn::NativeBuffer> mgn::MirClientHostConnection::create_buffer(
+    geom::Size size, uint32_t native_format, uint32_t native_flags)
+{
+    if (auto ext = mir_extension_gbm_buffer_v1(mir_connection))
+    {
+        return std::make_shared<HostBuffer>(mir_connection, ext, size, native_format, native_flags);
+    }
+
+    if (auto ext = mir_extension_android_buffer_v1(mir_connection))
+    {
+        return std::make_shared<HostBuffer>(mir_connection, ext, size, native_format, native_flags);
+    }
+
+    BOOST_THROW_EXCEPTION(std::runtime_error("could not create hardware buffer"));
+}
+
 std::unique_ptr<mgn::HostSurfaceSpec> mgn::MirClientHostConnection::create_surface_spec()
 {
     return std::make_unique<SurfaceSpec>(mir_connection);
@@ -714,8 +793,7 @@
 
 bool mgn::MirClientHostConnection::supports_passthrough()
 {
-    auto buffer = create_buffer(mg::BufferProperties(geom::Size{1, 1} , mir_pixel_format_abgr_8888, mg::BufferUsage::software));
-
+    auto buffer = create_buffer(geom::Size{1, 1} , mir_pixel_format_abgr_8888);
     auto hints = buffer->egl_image_creation_hints();
     if (std::get<1>(hints) == nullptr && std::get<2>(hints) == nullptr)
         return false;

=== modified file 'src/server/graphics/nested/mir_client_host_connection.h'
--- src/server/graphics/nested/mir_client_host_connection.h	2016-12-09 02:54:31 +0000
+++ src/server/graphics/nested/mir_client_host_connection.h	2017-01-12 13:57:10 +0000
@@ -86,6 +86,8 @@
     void set_input_event_callback(std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> const& cb) override;
     void emit_input_event(MirEvent const& cb, mir::geometry::Rectangle const& source_frame) override;
     std::shared_ptr<NativeBuffer> create_buffer(graphics::BufferProperties const&) override;
+    std::shared_ptr<NativeBuffer> create_buffer(geometry::Size, MirPixelFormat) override;
+    std::shared_ptr<NativeBuffer> create_buffer(geometry::Size, uint32_t format, uint32_t flags) override;
     bool supports_passthrough() override;
 
     optional_value<std::shared_ptr<MesaAuthExtension>> auth_extension() override;

=== modified file 'src/server/graphics/nested/platform.cpp'
--- src/server/graphics/nested/platform.cpp	2016-10-11 17:04:43 +0000
+++ src/server/graphics/nested/platform.cpp	2017-01-12 13:57:10 +0000
@@ -73,17 +73,12 @@
     {
     }
 
-    std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& buffer_properties) override
+    std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& properties) override
     {
-        if ((buffer_properties.size.width >= mir::geometry::Width{480}) &&
-            (buffer_properties.size.height >= mir::geometry::Height{480}))
-        {
-            return std::make_shared<mgn::Buffer>(connection, buffer_properties);
-        }
+        if (passthrough_candidate(properties.size))
+            return std::make_shared<mgn::Buffer>(connection, properties);
         else
-        {
-            return guest_allocator->alloc_buffer(buffer_properties);
-        }
+            return guest_allocator->alloc_buffer(properties);
     }
 
     std::vector<MirPixelFormat> supported_pixel_formats() override
@@ -92,6 +87,10 @@
     }
 
 private:
+    bool passthrough_candidate(mir::geometry::Size size)
+    {
+        return (size.width >= mir::geometry::Width{480}) && (size.height >= mir::geometry::Height{480});
+    }
     std::shared_ptr<mgn::HostConnection> const connection;
     std::shared_ptr<mg::GraphicBufferAllocator> const guest_allocator;
 };

=== modified file 'tests/include/mir/test/doubles/stub_host_connection.h'
--- tests/include/mir/test/doubles/stub_host_connection.h	2017-01-09 06:48:47 +0000
+++ tests/include/mir/test/doubles/stub_host_connection.h	2017-01-12 13:57:10 +0000
@@ -140,6 +140,14 @@
     {
         return nullptr;
     }
+    std::shared_ptr<graphics::nested::NativeBuffer> create_buffer(geometry::Size, MirPixelFormat)
+    {
+        return nullptr;
+    }
+    std::shared_ptr<graphics::nested::NativeBuffer> create_buffer(geometry::Size, uint32_t, uint32_t)
+    {
+        return nullptr;
+    }
 
     MirNativeBuffer* get_native_handle(MirBuffer*)
     {

=== modified file 'tests/unit-tests/platforms/nested/test_buffer.cpp'
--- tests/unit-tests/platforms/nested/test_buffer.cpp	2016-12-14 06:27:05 +0000
+++ tests/unit-tests/platforms/nested/test_buffer.cpp	2017-01-12 13:57:10 +0000
@@ -62,14 +62,17 @@
 
 struct MockHostConnection : mtd::StubHostConnection
 {
-    MOCK_METHOD1(create_buffer, std::shared_ptr<mgn::NativeBuffer>(mg::BufferProperties const&));
+    MOCK_METHOD2(create_buffer, std::shared_ptr<mgn::NativeBuffer>(geom::Size, MirPixelFormat));
+    MOCK_METHOD3(create_buffer, std::shared_ptr<mgn::NativeBuffer>(geom::Size, uint32_t, uint32_t));
 };
 
 struct NestedBuffer : Test
 {
     NestedBuffer()
     {
-        ON_CALL(mock_connection, create_buffer(_))
+        ON_CALL(mock_connection, create_buffer(_,_))
+            .WillByDefault(Return(client_buffer));
+        ON_CALL(mock_connection, create_buffer(_,_,_))
             .WillByDefault(Return(client_buffer));
         ON_CALL(*client_buffer, size())
             .WillByDefault(Return(sw_properties.size));
@@ -95,11 +98,15 @@
     }
 
     NiceMock<MockHostConnection> mock_connection;
-    mg::BufferProperties sw_properties{{1, 1}, mir_pixel_format_abgr_8888, mg::BufferUsage::software};
-    mg::BufferProperties hw_properties{{1, 1}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware};
+    geom::Size size {1, 1};
+    MirPixelFormat pf = mir_pixel_format_abgr_8888;
+    mg::BufferProperties sw_properties{size, pf, mg::BufferUsage::software};
+    mg::BufferProperties hw_properties{size, pf, mg::BufferUsage::hardware};
 
     std::shared_ptr<MockNativeBuffer> client_buffer = std::make_shared<NiceMock<MockNativeBuffer>>();
 
+    uint32_t native_pf = 0x44;
+    uint32_t native_flags = 0x48;
     unsigned int data = 0x11111111;
     int stride_with_padding = sw_properties.size.width.as_int() * MIR_BYTES_PER_PIXEL(sw_properties.format) + 4;
 
@@ -108,37 +115,44 @@
 };
 }
 
-TEST_F(NestedBuffer, creates_buffer_when_constructed)
-{
-    EXPECT_CALL(mock_connection, create_buffer(sw_properties))
-        .WillOnce(Return(client_buffer));
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+TEST_F(NestedBuffer, creates_sw_buffer_when_constructed)
+{
+    EXPECT_CALL(mock_connection, create_buffer(size, pf))
+        .WillOnce(Return(client_buffer));
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
+}
+
+TEST_F(NestedBuffer, creates_hw_buffer_when_constructed)
+{
+    EXPECT_CALL(mock_connection, create_buffer(size, native_pf, native_flags))
+        .WillOnce(Return(client_buffer));
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, native_pf, native_flags);
 }
 
 TEST_F(NestedBuffer, generates_valid_id)
 {
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
     EXPECT_THAT(buffer.id().as_value(), Gt(0u));
 }
 
 TEST_F(NestedBuffer, has_correct_properties)
 {
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
-    EXPECT_THAT(buffer.size(), Eq(sw_properties.size));
-    EXPECT_THAT(buffer.pixel_format(), Eq(sw_properties.format));
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
+    EXPECT_THAT(buffer.size(), Eq(size));
+    EXPECT_THAT(buffer.pixel_format(), Eq(pf));
 }
 
 TEST_F(NestedBuffer, sw_support_if_requested)
 {
 
     {
-        mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+        mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
         EXPECT_THAT(dynamic_cast<mrs::PixelSource*>(buffer.native_buffer_base()), Ne(nullptr));
         EXPECT_THAT(dynamic_cast<mrg::TextureSource*>(buffer.native_buffer_base()), Ne(nullptr));
     }
 
     {
-        mgn::Buffer buffer(mt::fake_shared(mock_connection), hw_properties);
+        mgn::Buffer buffer(mt::fake_shared(mock_connection), size, native_pf, native_flags);
         EXPECT_THAT(dynamic_cast<mrs::PixelSource*>(buffer.native_buffer_base()), Eq(nullptr));
         EXPECT_THAT(dynamic_cast<mrg::TextureSource*>(buffer.native_buffer_base()), Ne(nullptr));
     }
@@ -148,7 +162,7 @@
 {
     unsigned int data = 0x11223344;
     unsigned int new_data = 0x11111111;
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
 
     EXPECT_CALL(*client_buffer, get_graphics_region())
         .WillOnce(Invoke([&, this] { return generate_region(reinterpret_cast<char*>(&data)); }));
@@ -160,7 +174,7 @@
 
 TEST_F(NestedBuffer, checks_for_null_vaddr)
 {
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
 
     EXPECT_CALL(*client_buffer, get_graphics_region())
         .WillOnce(Invoke([&, this] { return generate_region(nullptr); }));
@@ -177,7 +191,7 @@
 TEST_F(NestedBuffer, throws_if_incorrect_sizing)
 {
     auto too_large_size = 4 * sizeof(data);
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
     auto pixel_source = dynamic_cast<mir::renderer::software::PixelSource*>(buffer.native_buffer_base());
     ASSERT_THAT(pixel_source, Ne(nullptr));
     EXPECT_THROW({
@@ -188,7 +202,7 @@
 TEST_F(NestedBuffer, reads_from_region)
 {
     unsigned int read_data = 0x11111111;
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
 
     EXPECT_CALL(*client_buffer, get_graphics_region())
         .WillOnce(Invoke([&, this] { return generate_region(reinterpret_cast<char*>(&read_data)); }));
@@ -205,7 +219,7 @@
     ON_CALL(*client_buffer, egl_image_creation_hints())
         .WillByDefault(Return(std::tuple<EGLenum, EGLClientBuffer, EGLint*>{}));
 
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), hw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, native_pf, native_flags);
     auto native_base = buffer.native_buffer_base();
     ASSERT_THAT(native_base, Ne(nullptr));
     auto texture_source = dynamic_cast<mir::renderer::gl::TextureSource*>(native_base);
@@ -227,7 +241,7 @@
     int fake_context1 = 113;
     int fake_context2 = 114;
 
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), hw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, native_pf, native_flags);
     auto texture_source = dynamic_cast<mir::renderer::gl::TextureSource*>(buffer.native_buffer_base());
     ASSERT_THAT(texture_source, Ne(nullptr));
 
@@ -250,7 +264,7 @@
 
 TEST_F(NestedBuffer, has_correct_stride)
 {
-    mgn::Buffer buffer(mt::fake_shared(mock_connection), sw_properties);
+    mgn::Buffer buffer(mt::fake_shared(mock_connection), size, pf);
     auto pixel_source = dynamic_cast<mir::renderer::software::PixelSource*>(buffer.native_buffer_base());
     ASSERT_THAT(pixel_source, Ne(nullptr));
     EXPECT_THAT(pixel_source->stride().as_int(), Eq(stride_with_padding));