Merge lp:~alan-griffiths/mir/MirBlob into lp:mir

[Alan Griffiths]

client API: Add MirBlob - a tool for serializing and deserializing data. Initially just MirDisplayConfiguration

client API: Add MirBlob - a tool for serializing and deserializing data. Initially just MirDisplayConfiguration

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2905
http://jenkins.qa.ubuntu.com/job/mir-ci/4837/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3881
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2788
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3827
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/986
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/986/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3827
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3827/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/6555
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/23171

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Looks good code-wise, but I have a few concerns about the general approach. I think it should be up to the users to serialize the data in a way that's convenient for their use case.

By providing the serialization ourselves, we are burdening Mir with complexity and responsibilities that I am not convinced belong there. For example, we are effectively promising that mir_blob_to_display_configuration() will remain backwards compatible (i.e., it can decode blobs from previous versions) forever, since with our opaque serialization scheme there is no upgrade/transition path that doesn't break the system.

Furthermore, I don't like that we are enticing users to use a binary, opaque serialization scheme, instead of a textual/editable one. Of course, they can always choose to ignore our functions and do their own serialization, but the lure of the dark side may be difficult to resist :)

Bottom line: I understand that shells may find this useful, but I don't think the convenience is worth the extra burden on the Mir side.

review: Abstain

[Alan Griffiths (alan-griffiths)]

Well, we already have the burden of marshalling display configurations for IPC and the protobuf handlers we use are able to provide a lot of the compatibility support you mention.

While there are costs, the alternative is that the display configuration structs get locked in even more tightly to user code - making any changes there (scale anyone?) more risky.

[Andreas Pokorny (andreas-pokorny)]

Compared to our clients mirserver is better suited to keep the blob format compatible or even migrate it when versioned. I never looked how protobuf encodes it, is the current format suited for that? I would have expected some version info..

review: Needs Information

[Alan Griffiths (alan-griffiths)]

> Compared to our clients mirserver is better suited to keep the blob format
> compatible or even migrate it when versioned. I never looked how protobuf
> encodes it, is the current format suited for that? I would have expected some
> version info..

Protobuf allows us to mark fields as "optional" and test for their existence. When updating this buffer definition we already follow the guidelines for backwards compatibility[1], so I don't this code is a big overhead.

[1] https://developers.google.com/protocol-buffers/docs/cpptutorial?hl=en#extending-a-protocol-buffer

[Alexandros Frantzis (afrantzis)]

> Protobuf allows us to mark fields as "optional" and test for their existence. When updating this buffer definition we already follow the guidelines for backwards compatibility[1], so I don't this code is a big overhead.

This will work, as long as we stick to protobuf, which is a technology that we may want to replace in the future (at least on the IPC side). We can keep depending on it just for this use case, but perhaps that's an overkill.

[Alan Griffiths (alan-griffiths)]

> > Protobuf allows us to mark fields as "optional" and test for their
> existence. When updating this buffer definition we already follow the
> guidelines for backwards compatibility[1], so I don't this code is a big
> overhead.
>
> This will work, as long as we stick to protobuf, which is a technology that we
> may want to replace in the future (at least on the IPC side). We can keep
> depending on it just for this use case, but perhaps that's an overkill.

That's true but, while we're speculating about hypothetical changes:

1. we could reinstate and move to the Binder based transport we used to have as Binder is now in all kernels we target.

2. we could drop the client API in favour of a Wayland based protocol.

In the first case we can stick with protobuf, in the second, the structure marshaled by this MP becomes irrelevant.

I suggest this is good enough for now and we can deal with "migration" if the need ever occurs.

[Andreas Pokorny (andreas-pokorny)]

ok

review: Approve

[Gerry Boland (gerboland)]

Does this need to be built into Mir directly? Could it be a helper library that is Mir data structure aware?

If it serializes settings, it is logical to expect that not just the shell would want to edit those settings.

I'm also interested in the human readability of this blob. I'd rather not see us introducing yet another binary format, especially one based on an internally-used library. It could be JSON or XML or something simple.

[Alan Griffiths (alan-griffiths)]

> Does this need to be built into Mir directly? Could it be a helper library
> that is Mir data structure aware?

What advantage would there be to separating this into a new helper library? It shares code with other functions in libmirclient.

> If it serializes settings, it is logical to expect that not just the shell
> would want to edit those settings.

It is logical that serialization is available to the same code that can (already) edit display configurations through the client API.

> I'm also interested in the human readability of this blob. I'd rather not see
> us introducing yet another binary format, especially one based on an
> internally-used library. It could be JSON or XML or something simple.

I'd not realised human readability was a requirement, OTOH parsing JSON or XML would introduce a new dependency.

[Gerry Boland (gerboland)]

> > Does this need to be built into Mir directly? Could it be a helper library
> > that is Mir data structure aware?
>
> What advantage would there be to separating this into a new helper library? It
> shares code with other functions in libmirclient.

You implying that this API will be available in libmirclient, so any client can serialize/deserialize?

> > If it serializes settings, it is logical to expect that not just the shell
> > would want to edit those settings.
>
> It is logical that serialization is available to the same code that can
> (already) edit display configurations through the client API.

Above question will clarify that for me.

> > I'm also interested in the human readability of this blob. I'd rather not
> see
> > us introducing yet another binary format, especially one based on an
> > internally-used library. It could be JSON or XML or something simple.
>
> I'd not realised human readability was a requirement, OTOH parsing JSON or XML
> would introduce a new dependency.

Interested, not requiring. There are advantages to human readability of configuration files. It's not my call to say if we should make that a requirement, but I would like it considered.

As the API consumer, I'm perfectly happy.

[Alan Griffiths (alan-griffiths)]

> > > Does this need to be built into Mir directly? Could it be a helper library
> > > that is Mir data structure aware?
> >
> > What advantage would there be to separating this into a new helper library?
> It
> > shares code with other functions in libmirclient.
>
> You implying that this API will be available in libmirclient, so any client
> can serialize/deserialize?

Yes. Were you wanting something different?

[lp:~alan-griffiths/mir/MirBlob]

2906. By Alan Griffiths on 2015-09-16

abort on bad data

2907. By Alan Griffiths on 2015-09-16

merge lp:mir

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2907
http://jenkins.qa.ubuntu.com/job/mir-ci/4935/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4014
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2921
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3956
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1085
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1085/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3957
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3957/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/6666
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/23378

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

> > > > Does this need to be built into Mir directly? Could it be a helper
> library
> > > > that is Mir data structure aware?
> > >
> > > What advantage would there be to separating this into a new helper
> library?
> > It
> > > shares code with other functions in libmirclient.
> >
> > You implying that this API will be available in libmirclient, so any client
> > can serialize/deserialize?
>
> Yes. Were you wanting something different?

No, that's fine.

[Gerry Boland (gerboland)]

I'm ok with this. Still wary about the binary format, but can deal with that if we need to later

review: Approve

=== modified file 'include/client/mir_toolkit/client_types.h'
--- include/client/mir_toolkit/client_types.h	2015-07-25 08:10:48 +0000
+++ include/client/mir_toolkit/client_types.h	2015-09-16 16:41:31 +0000
@@ -44,6 +44,7 @@
 typedef struct MirPromptSession MirPromptSession;
 typedef struct MirBufferStream MirBufferStream;
 typedef struct MirPersistentId MirPersistentId;
+typedef struct MirBlob MirBlob;
 
 /**
  * Returned by asynchronous functions. Must not be free'd by

=== added file 'include/client/mir_toolkit/mir_blob.h'
--- include/client/mir_toolkit/mir_blob.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/mir_blob.h	2015-09-16 16:41:31 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ */
+
+#ifndef MIR_TOOLKIT_MIR_BLOB_H_
+#define MIR_TOOLKIT_MIR_BLOB_H_
+
+#include <mir_toolkit/client_types.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Create a blob from a display configuration
+ *
+ * \param [in] configuration  The display configuration
+ * \return                 A blob
+ */
+MirBlob* mir_blob_from_display_configuration(MirDisplayConfiguration* configuration);
+
+/**
+ * Create a blob from a buffer.
+ * \note this does not copy the data, the buffer is assumed to be available
+ *       until the blob is released.
+ *
+ * \param [in] buffer      the buffer
+ * \param [in] buffer_size the buffer size
+ * \return                 A blob
+ */
+MirBlob* mir_blob_onto_buffer(void const* buffer, size_t buffer_size);
+
+/**
+ * Create a blob from a display configuration
+ *
+ * \warning will abort() if the blob doesn't represent a meaningful display configuration
+ *
+ * \param [in] blob        The blob
+ * \return                 A display configuration
+ */
+MirDisplayConfiguration* mir_blob_to_display_configuration(MirBlob* blob);
+
+/**
+ * Get the size of a blob
+ * \param [in] blob        The blob
+ * \return                 the size
+ */
+size_t mir_blob_size(MirBlob* blob);
+
+/**
+ * Get the data of a blob
+ * \param [in] blob        The blob
+ * \return                 the data
+ */
+void const* mir_blob_data(MirBlob* blob);
+
+/**
+ * Release a blob object
+ * \param [in] blob        The blob
+ */
+void mir_blob_release(MirBlob* blob);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_MIR_BLOB_H_ */

=== modified file 'include/test/mir/test/display_config_matchers.h'
--- include/test/mir/test/display_config_matchers.h	2015-09-08 03:25:06 +0000
+++ include/test/mir/test/display_config_matchers.h	2015-09-16 16:41:31 +0000
@@ -63,6 +63,9 @@
 bool compare_display_configurations(protobuf::DisplayConfiguration const& protobuf_config,
                                     graphics::DisplayConfiguration const& display_config);
 
+bool compare_display_configurations(MirDisplayConfiguration const* client_config1,
+                                    MirDisplayConfiguration const* client_config2);
+
 bool compare_display_configurations(MirDisplayConfiguration const& client_config,
                                     protobuf::DisplayConfiguration const& protobuf_config);
 

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2015-08-12 06:37:54 +0000
+++ src/client/CMakeLists.txt	2015-09-16 16:41:31 +0000
@@ -45,6 +45,7 @@
   error_connections.cpp
   event.cpp
   event_printer.cpp
+  mir_blob.cpp
   mir_connection.cpp
   mir_connection_api.cpp
   mir_wait_handle.cpp

=== added file 'src/client/mir_blob.cpp'
--- src/client/mir_blob.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_blob.cpp	2015-09-16 16:41:31 +0000
@@ -0,0 +1,229 @@
+/*
+ * Copyright © 2015 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_blob.h"
+#include "mir_protobuf.pb.h"
+
+#include "mir/uncaught.h"
+
+namespace mp = mir::protobuf;
+
+struct MirBlob
+{
+    virtual size_t size() const = 0;
+    virtual void const* data() const = 0;
+
+    virtual ~MirBlob() = default;
+};
+
+namespace
+{
+struct MirManagedBlob : MirBlob
+{
+
+    size_t size() const override { return size_; }
+    void const* data() const override { return  data_; }
+    google::protobuf::uint8* data() { return data_; }
+
+    size_t const size_;
+    google::protobuf::uint8*  const data_;
+
+    MirManagedBlob(size_t const size) : size_{size}, data_{new google::protobuf::uint8[size]} {}
+    ~MirManagedBlob() { delete[] data_; }
+};
+
+struct MirUnmanagedBlob : MirBlob
+{
+    size_t size() const override { return size_; }
+    void const* data() const override { return  data_; }
+
+    size_t const size_;
+    void const* const data_;
+
+    MirUnmanagedBlob(size_t const size, void const* data) : size_{size}, data_{data} {}
+};
+}
+
+
+MirBlob* mir_blob_from_display_configuration(MirDisplayConfiguration* configuration)
+try
+{
+    mp::DisplayConfiguration protobuf_config;
+
+    for (auto const* card = configuration->cards; card != configuration->cards+configuration->num_cards; ++card)
+    {
+        auto protobuf_card = protobuf_config.add_display_card();
+        protobuf_card->set_card_id(card->card_id);
+        protobuf_card->set_max_simultaneous_outputs(card->max_simultaneous_outputs);
+    }
+
+    for (auto const* output = configuration->outputs;
+         output != configuration->outputs+configuration->num_outputs;
+         ++output)
+    {
+        auto protobuf_output = protobuf_config.add_display_output();
+
+        protobuf_output->set_output_id(output->output_id);
+        protobuf_output->set_card_id(output->card_id);
+        protobuf_output->set_type(output->type);
+
+        for (auto const* format = output->output_formats;
+             format != output->output_formats+output->num_output_formats;
+             ++format)
+        {
+            protobuf_output->add_pixel_format(*format);
+        }
+
+        for (auto const* mode = output->modes;
+             mode != output->modes+output->num_modes;
+             ++mode)
+        {
+            auto protobuf_output_mode = protobuf_output->add_mode();
+            protobuf_output_mode->set_horizontal_resolution(mode->horizontal_resolution);
+            protobuf_output_mode->set_vertical_resolution(mode->vertical_resolution);
+            protobuf_output_mode->set_refresh_rate(mode->refresh_rate);
+        }
+
+        protobuf_output->set_preferred_mode(output->preferred_mode);
+
+        protobuf_output->set_physical_width_mm(output->physical_width_mm);
+        protobuf_output->set_physical_height_mm(output->physical_height_mm);
+
+        protobuf_output->set_connected(output->connected);
+        protobuf_output->set_used(output->used);
+        protobuf_output->set_position_x(output->position_x);
+        protobuf_output->set_position_y(output->position_y);
+        protobuf_output->set_current_mode(output->current_mode);
+        protobuf_output->set_current_format(output->current_format);
+        protobuf_output->set_power_mode(output->power_mode);
+        protobuf_output->set_orientation(output->orientation);
+    }
+
+    auto blob = std::make_unique<MirManagedBlob>(static_cast<size_t>(protobuf_config.ByteSize()));
+
+    protobuf_config.SerializeWithCachedSizesToArray(blob->data());
+
+    return blob.release();
+}
+catch (std::exception const& x)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(x);
+    return nullptr;
+}
+
+MirBlob* mir_blob_onto_buffer(void const* buffer, size_t buffer_size)
+try
+{
+    return new MirUnmanagedBlob{buffer_size, buffer};
+}
+catch (std::exception const& x)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(x);
+    return nullptr;
+}
+
+MirDisplayConfiguration* mir_blob_to_display_configuration(MirBlob* blob)
+try
+{
+    mp::DisplayConfiguration protobuf_config;
+
+    protobuf_config.ParseFromArray(mir_blob_data(blob), mir_blob_size(blob));
+
+    auto new_config = new MirDisplayConfiguration;
+
+    new_config->num_cards = protobuf_config.display_card_size();
+    new_config->cards = new MirDisplayCard[new_config->num_cards];
+
+    for (auto i = 0u; i != new_config->num_cards; ++i)
+    {
+        auto const& protobuf_card = protobuf_config.display_card(i);
+        auto& card = new_config->cards[i];
+        card.card_id = protobuf_card.card_id();
+        card.max_simultaneous_outputs = protobuf_card.max_simultaneous_outputs();
+    }
+
+    new_config->num_outputs = protobuf_config.display_output_size();
+    new_config->outputs = new MirDisplayOutput[new_config->num_outputs];
+
+    for (auto i = 0u; i != new_config->num_outputs; ++i)
+    {
+        auto const& protobuf_output = protobuf_config.display_output(i);
+        auto& output = new_config->outputs[i];
+
+        output.output_id = protobuf_output.output_id();
+        output.card_id = protobuf_output.card_id();
+        output.type = static_cast<MirDisplayOutputType>(protobuf_output.type());
+
+        output.num_output_formats = protobuf_output.pixel_format_size();
+        output.output_formats = new MirPixelFormat[output.num_output_formats];
+
+        output.num_modes = protobuf_output.mode_size();
+        output.modes = new MirDisplayMode[output.num_modes];
+
+        for (auto i = 0u; i != output.num_output_formats; ++i)
+        {
+            output.output_formats[i] = static_cast<MirPixelFormat>(protobuf_output.pixel_format(i));
+        }
+
+        for (auto i = 0u; i != output.num_modes; ++i)
+        {
+            auto const& protobuf_mode = protobuf_output.mode(i);
+            auto& mode = output.modes[i];
+
+            mode.horizontal_resolution = protobuf_mode.horizontal_resolution();
+            mode.vertical_resolution = protobuf_mode.vertical_resolution();
+            mode.refresh_rate = protobuf_mode.refresh_rate();
+        }
+
+        output.preferred_mode = protobuf_output.preferred_mode();
+
+        output.physical_width_mm = protobuf_output.physical_width_mm();
+        output.physical_height_mm = protobuf_output.physical_height_mm();
+
+        output.connected = protobuf_output.connected();
+        output.used = protobuf_output.used();
+        output.position_x = protobuf_output.position_x();
+        output.position_y = protobuf_output.position_y();
+        output.current_mode = protobuf_output.current_mode();
+        output.current_format = static_cast<MirPixelFormat>(protobuf_output.current_format());
+        output.orientation = static_cast<MirOrientation>(protobuf_output.orientation());
+        output.power_mode = static_cast<MirPowerMode>(protobuf_output.power_mode());
+    }
+
+    return new_config;
+}
+catch (std::exception const& x)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(x);
+    abort();
+}
+
+size_t mir_blob_size(MirBlob* blob)
+{
+    return blob->size();
+}
+
+void const* mir_blob_data(MirBlob* blob)
+{
+    return blob->data();
+}
+
+void mir_blob_release(MirBlob* blob)
+{
+    delete blob;
+}

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2015-09-09 03:13:35 +0000
+++ src/client/symbols.map	2015-09-16 16:41:31 +0000
@@ -182,6 +182,16 @@
   local: *;
 } MIR_CLIENT_9.1;
 
+MIR_CLIENT_9v17 {
+    mir_blob_from_display_configuration;
+    mir_blob_size;
+    mir_blob_data;
+    mir_blob_release;
+    mir_blob_onto_buffer;
+    mir_blob_to_display_configuration;
+    mir_blob_release;
+} MIR_CLIENT_9.2;
+
 MIR_CLIENT_DETAIL_9 {
   global:
     extern "C++" { 

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2015-09-09 18:59:38 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2015-09-16 16:41:31 +0000
@@ -26,6 +26,7 @@
   test_server_shutdown.cpp
   test_client_focus_notification.cpp
   test_client_authorization.cpp
+  test_mirblob.cpp
   test_nested_mir.cpp
   test_nested_input.cpp
   test_display_configuration.cpp

=== added file 'tests/acceptance-tests/test_mirblob.cpp'
--- tests/acceptance-tests/test_mirblob.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_mirblob.cpp	2015-09-16 16:41:31 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_blob.h"
+#include "mir_toolkit/mir_client_library.h"
+
+#include "mir_test_framework/connected_client_with_a_surface.h"
+#include "mir/test/display_config_matchers.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cstring>
+
+using MirBlobAPI = mir_test_framework::ConnectedClientWithASurface;
+using mir::test::DisplayConfigMatches;
+
+TEST_F(MirBlobAPI, can_serialize_display_configuration)
+{
+    std::vector<uint8_t> buffer;
+
+    auto const save_display_config = mir_connection_create_display_config(connection);
+
+    {
+        auto const save_blob = mir_blob_from_display_configuration(save_display_config);
+
+        buffer.resize(mir_blob_size(save_blob));
+        memcpy(buffer.data(), mir_blob_data(save_blob), buffer.size());
+        mir_blob_release(save_blob);
+    }
+
+    MirDisplayConfiguration* restore_display_config;
+    {
+        auto const restore_blob = mir_blob_onto_buffer(buffer.data(), buffer.size());
+        restore_display_config = mir_blob_to_display_configuration(restore_blob);
+        mir_blob_release(restore_blob);
+    }
+
+    EXPECT_THAT(save_display_config, DisplayConfigMatches(restore_display_config));
+
+    mir_display_config_destroy(restore_display_config);
+    mir_display_config_destroy(save_display_config);
+}
\ No newline at end of file

=== modified file 'tests/mir_test/display_config_matchers.cpp'
--- tests/mir_test/display_config_matchers.cpp	2015-09-08 03:25:06 +0000
+++ tests/mir_test/display_config_matchers.cpp	2015-09-16 16:41:31 +0000
@@ -278,6 +278,14 @@
     return compare_display_configurations(config1, display_config);
 }
 
+bool mt::compare_display_configurations(MirDisplayConfiguration const* client_config1,
+                                        MirDisplayConfiguration const* client_config2)
+{
+    TestDisplayConfiguration config1{*client_config1};
+    TestDisplayConfiguration config2{*client_config2};
+    return compare_display_configurations(config1, config2);
+}
+
 bool mt::compare_display_configurations(MirDisplayConfiguration const& client_config,
                                         mp::DisplayConfiguration const& protobuf_config)
 {