Merge lp:mir/0.13 into lp:mir/ubuntu

[Alberto Aguirre]

Mir 0.13.3 release

Mir 0.13.3 release

[Kevin DuBois (kdub)]

lgtm

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2555
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/50/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-wily-i386-build/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/408
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-armhf-ci/4/console

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

review: Needs Fixing (continuous-integration)

[Alberto Aguirre (albaguirre)]

Umm it's always these tests:

[ FAILED ] GLibMainLoopAlarmTest.propagates_exception_from_alarm
[ FAILED ] SimpleDispatchThreadTest.keeps_dispatching_after_signal_interruption

But they don't fail in the silo build...ummm.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2555
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/51/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-wily-i386-build/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/413
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-amd64-ci/5/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-wily-armhf-ci/5/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Apparently not landed yet, but is released already (!?) :)

https://launchpad.net/ubuntu/+source/mir
https://launchpad.net/mir/+milestone/0.13.3

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-06-02 23:18:42 +0000
+++ CMakeLists.txt	2015-06-17 19:19:38 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 13) # This should change at least with every MIRSERVER_ABI
-set(MIR_VERSION_PATCH 2)
+set(MIR_VERSION_PATCH 3)
 
 add_definitions(-DMIR_VERSION_MAJOR=${MIR_VERSION_MAJOR})
 add_definitions(-DMIR_VERSION_MINOR=${MIR_VERSION_MINOR})
 
=== modified file 'debian/changelog'
--- debian/changelog	2015-06-05 17:51:41 +0000
+++ debian/changelog	2015-06-17 19:19:38 +0000
@@ -1,3 +1,12 @@
+mir (0.13.3) UNRELEASED; urgency=medium
+
+  * New upstream release 0.13.3 (https://launchpad.net/mir/+milestone/0.13.3)
+    - Bug fixes:
+      . mir-client-platform-mesa-dev package dep is incorrect (LP: #1465642)
+      . Avoid allocating mir protobuf message objects on stack (LP: #1465883)
+
+ -- Alberto Aguirre <[e-mail]>  Wed, 17 Jun 2015 14:11:53 -0500
+
 mir (0.13.2+15.10.20150605-0ubuntu1) wily; urgency=medium
 
   [ Alberto Aguirre ]
 
=== modified file 'debian/control'
--- debian/control	2015-06-05 17:48:17 +0000
+++ debian/control	2015-06-17 19:19:38 +0000
@@ -317,7 +317,7 @@
 Architecture: i386 amd64 armhf arm64 powerpc ppc64el
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmircommon-dev,
+Depends: libmirclient-dev,
          ${misc:Depends},
 Description: Display server for Ubuntu - client platform library for Mesa development files
  Mir is a display server running on linux systems, with a focus on efficiency,
 
=== modified file 'src/client/buffer_stream.cpp'
--- src/client/buffer_stream.cpp	2015-04-23 14:09:57 +0000
+++ src/client/buffer_stream.cpp	2015-06-17 19:19:38 +0000
@@ -19,6 +19,7 @@
 #define MIR_LOG_COMPONENT "MirBufferStream"
 
 #include "buffer_stream.h"
+#include "make_protobuf_object.h"
 
 #include "mir/frontend/client_constants.h"
 
@@ -96,11 +97,11 @@
     : display_server(server),
       mode(mode),
       client_platform(client_platform),
-      protobuf_bs(protobuf_bs),
+      protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>(protobuf_bs)},
       buffer_depository{client_platform->create_buffer_factory(), mir::frontend::client_buffer_cache_size},
       swap_interval_(1),
-      perf_report(perf_report)
-      
+      perf_report(perf_report),
+      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()}
 {
     created(nullptr, nullptr);
     perf_report->name_surface(surface_name.c_str());
@@ -115,21 +116,23 @@
     : display_server(server),
       mode(BufferStreamMode::Producer),
       client_platform(client_platform),
+      protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>()},
       buffer_depository{client_platform->create_buffer_factory(), mir::frontend::client_buffer_cache_size},
       swap_interval_(1),
-      perf_report(perf_report)
+      perf_report(perf_report),
+      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()}
 {
     perf_report->name_surface(std::to_string(reinterpret_cast<long int>(this)).c_str());
 
     create_wait_handle.expect_result();
     try
     {
-        server.create_buffer_stream(0, &parameters, &protobuf_bs, gp::NewCallback(this, &mcl::BufferStream::created, callback,
+        server.create_buffer_stream(0, &parameters, protobuf_bs.get(), gp::NewCallback(this, &mcl::BufferStream::created, callback,
             context));
     }
     catch (std::exception const& ex)
     {
-        protobuf_bs.set_error(std::string{"Error invoking create buffer stream: "} +
+        protobuf_bs->set_error(std::string{"Error invoking create buffer stream: "} +
                               boost::diagnostic_information(ex));
     }
         
@@ -137,12 +140,12 @@
 
 void mcl::BufferStream::created(mir_buffer_stream_callback callback, void *context)
 {
-    if (!protobuf_bs.has_id() || protobuf_bs.has_error())
-        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs.error())));
-    if (!protobuf_bs.has_buffer())
+    if (!protobuf_bs->has_id() || protobuf_bs->has_error())
+        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
+    if (!protobuf_bs->has_buffer())
         BOOST_THROW_EXCEPTION(std::runtime_error("Buffer stream did not come with a buffer"));
 
-    process_buffer(protobuf_bs.buffer());
+    process_buffer(protobuf_bs->buffer());
     egl_native_window_ = client_platform->create_egl_native_window(this);
 
     if (callback)
@@ -173,7 +176,7 @@
 
     try
     {
-        auto pixel_format = static_cast<MirPixelFormat>(protobuf_bs.pixel_format());
+        auto pixel_format = static_cast<MirPixelFormat>(protobuf_bs->pixel_format());
         buffer_depository.deposit_package(buffer_package,
             buffer.buffer_id(),
             cached_buffer_size, pixel_format);
@@ -192,40 +195,37 @@
 
     secured_region.reset();
 
-    mir::protobuf::BufferStreamId buffer_stream_id;
-    buffer_stream_id.set_value(protobuf_bs.id().value());
-
-// TODO: We can fix the strange "ID casting" used below in the second phase
-// of buffer stream which generalizes and clarifies the server side logic.
+    // TODO: We can fix the strange "ID casting" used below in the second phase
+    // of buffer stream which generalizes and clarifies the server side logic.
     if (mode == mcl::BufferStreamMode::Producer)
     {
-        mp::BufferRequest request;
-        request.mutable_id()->set_value(protobuf_bs.id().value());
-        request.mutable_buffer()->set_buffer_id(protobuf_bs.buffer().buffer_id());
+        auto request = mcl::make_protobuf_object<mp::BufferRequest>();
+        request->mutable_id()->set_value(protobuf_bs->id().value());
+        request->mutable_buffer()->set_buffer_id(protobuf_bs->buffer().buffer_id());
 
         lock.unlock();
         next_buffer_wait_handle.expect_result();
 
         display_server.exchange_buffer(
             nullptr,
-            &request,
-            protobuf_bs.mutable_buffer(),
+            request.get(),
+            protobuf_bs->mutable_buffer(),
             google::protobuf::NewCallback(
             this, &mcl::BufferStream::next_buffer_received,
             done));
     }
     else
     {
-        mp::ScreencastId screencast_id;
-        screencast_id.set_value(protobuf_bs.id().value());
+        auto screencast_id = mcl::make_protobuf_object<mp::ScreencastId>();
+        screencast_id->set_value(protobuf_bs->id().value());
 
         lock.unlock();
         next_buffer_wait_handle.expect_result();
 
         display_server.screencast_buffer(
             nullptr,
-            &screencast_id,
-            protobuf_bs.mutable_buffer(),
+            screencast_id.get(),
+            protobuf_bs->mutable_buffer(),
             google::protobuf::NewCallback(
             this, &mcl::BufferStream::next_buffer_received,
             done));
@@ -263,7 +263,7 @@
 void mcl::BufferStream::next_buffer_received(
     std::function<void()> done)                                             
 {
-    process_buffer(protobuf_bs.buffer());
+    process_buffer(protobuf_bs->buffer());
 
     done();
 
@@ -278,8 +278,8 @@
         "",
         cached_buffer_size.width.as_int(),
         cached_buffer_size.height.as_int(),
-        static_cast<MirPixelFormat>(protobuf_bs.pixel_format()),
-        static_cast<MirBufferUsage>(protobuf_bs.buffer_usage()),
+        static_cast<MirPixelFormat>(protobuf_bs->pixel_format()),
+        static_cast<MirBufferUsage>(protobuf_bs->buffer_usage()),
         mir_display_output_id_invalid};
 }
 
@@ -311,20 +311,21 @@
         BOOST_THROW_EXCEPTION(std::logic_error("Attempt to set swap interval on screencast is invalid"));
     }
 
-    mp::SurfaceSetting setting, result;
-    setting.mutable_surfaceid()->set_value(protobuf_bs.id().value());
-    setting.set_attrib(attrib);
-    setting.set_ivalue(value);
+    auto setting = mcl::make_protobuf_object<mp::SurfaceSetting>();
+    auto result = mcl::make_protobuf_object<mp::SurfaceSetting>();
+    setting->mutable_surfaceid()->set_value(protobuf_bs->id().value());
+    setting->set_attrib(attrib);
+    setting->set_ivalue(value);
     lock.unlock();
 
     configure_wait_handle.expect_result();
-    display_server.configure_surface(0, &setting, &result,
+    display_server.configure_surface(0, setting.get(), result.get(),
         google::protobuf::NewCallback(this, &mcl::BufferStream::on_configured));
 
     configure_wait_handle.wait_for_all();
 
     lock.lock();
-    swap_interval_ = result.ivalue();
+    swap_interval_ = result->ivalue();
 }
 
 uint32_t mcl::BufferStream::get_current_buffer_id()
@@ -364,14 +365,14 @@
 MirWaitHandle* mcl::BufferStream::release(
         mir_buffer_stream_callback callback, void* context)
 {
-    mir::protobuf::BufferStreamId buffer_stream_id;
-    buffer_stream_id.set_value(protobuf_bs.id().value());
+    auto buffer_stream_id = mcl::make_protobuf_object<mir::protobuf::BufferStreamId>();
+    buffer_stream_id->set_value(protobuf_bs->id().value());
     
     release_wait_handle.expect_result();
     display_server.release_buffer_stream(
         nullptr,
-        &buffer_stream_id,
-        &protobuf_void,
+        buffer_stream_id.get(),
+        protobuf_void.get(),
         google::protobuf::NewCallback(
             this, &mcl::BufferStream::released, callback, context));
 
@@ -390,13 +391,13 @@
 {
     std::unique_lock<decltype(mutex)> lock(mutex);
     
-    return mf::BufferStreamId(protobuf_bs.id().value());
+    return mf::BufferStreamId(protobuf_bs->id().value());
 }
 
 bool mcl::BufferStream::valid() const
 {
     std::unique_lock<decltype(mutex)> lock(mutex);
-    return protobuf_bs.has_id() && !protobuf_bs.has_error();
+    return protobuf_bs->has_id() && !protobuf_bs->has_error();
 }
 
 void mcl::BufferStream::set_buffer_cache_size(unsigned int cache_size)
 
=== modified file 'src/client/buffer_stream.h'
--- src/client/buffer_stream.h	2015-04-23 14:09:57 +0000
+++ src/client/buffer_stream.h	2015-06-17 19:19:38 +0000
@@ -60,7 +60,7 @@
     BufferStream(mir::protobuf::DisplayServer& server,
         BufferStreamMode mode,
         std::shared_ptr<ClientPlatform> const& native_window_factory,
-        protobuf::BufferStream const& protobuf_bs,
+        mir::protobuf::BufferStream const& protobuf_bs,
         std::shared_ptr<PerfReport> const& perf_report,
         std::string const& surface_name);
     // For surfaceless buffer streams
@@ -121,7 +121,7 @@
     BufferStreamMode const mode;
     std::shared_ptr<ClientPlatform> const client_platform;
 
-    mir::protobuf::BufferStream protobuf_bs;
+    std::unique_ptr<mir::protobuf::BufferStream> protobuf_bs;
     mir::client::ClientBufferDepository buffer_depository;
     
     int swap_interval_;
@@ -134,7 +134,7 @@
     MirWaitHandle release_wait_handle;
     MirWaitHandle next_buffer_wait_handle;
     MirWaitHandle configure_wait_handle;
-    mir::protobuf::Void protobuf_void;
+    std::unique_ptr<mir::protobuf::Void> protobuf_void;
     
     std::shared_ptr<MemoryRegion> secured_region;
     
 
=== added file 'src/client/make_protobuf_object.h'
--- src/client/make_protobuf_object.h	1970-01-01 00:00:00 +0000
+++ src/client/make_protobuf_object.h	2015-06-17 19:19:38 +0000
@@ -0,0 +1,42 @@
+/*
+ * 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: Alberto Aguirre <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_MAKE_PROTOBUF_OBJECT_
+#define MIR_CLIENT_MAKE_PROTOBUF_OBJECT_
+
+namespace mir
+{
+namespace client
+{
+template <typename ProtobufType>
+auto make_protobuf_object()
+{
+    return std::unique_ptr<ProtobufType>{ProtobufType::default_instance().New()};
+}
+
+template <typename ProtobufType>
+auto make_protobuf_object(ProtobufType const& from)
+{
+    auto object = make_protobuf_object<ProtobufType>();
+    object->CopyFrom(from);
+    return object;
+}
+}
+}
+
+#endif
 
=== modified file 'src/client/mir_buffer_stream_api.cpp'
--- src/client/mir_buffer_stream_api.cpp	2015-03-31 02:35:42 +0000
+++ src/client/mir_buffer_stream_api.cpp	2015-06-17 19:19:38 +0000
@@ -23,6 +23,7 @@
 #include "mir_connection.h"
 #include "buffer_stream.h"
 #include "client_buffer_stream_factory.h"
+#include "make_protobuf_object.h"
 
 #include "mir/client_buffer.h"
 
@@ -68,13 +69,13 @@
     void *context)
 try
 {
-    mp::BufferStreamParameters params;
-    params.set_width(width);
-    params.set_height(height);
-    params.set_pixel_format(format);
-    params.set_buffer_usage(buffer_usage);
+    auto params = mcl::make_protobuf_object<mp::BufferStreamParameters>();
+    params->set_width(width);
+    params->set_height(height);
+    params->set_pixel_format(format);
+    params->set_buffer_usage(buffer_usage);
 
-    return connection->get_client_buffer_stream_factory()->make_producer_stream(connection->display_server(), params, callback, context)
+    return connection->get_client_buffer_stream_factory()->make_producer_stream(connection->display_server(), *params, callback, context)
         ->get_create_wait_handle();
 }
 catch (std::exception const& ex)
 
=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2015-04-01 19:39:19 +0000
+++ src/client/mir_connection.cpp	2015-06-17 19:19:38 +0000
@@ -20,6 +20,7 @@
 #include "mir_surface.h"
 #include "mir_prompt_session.h"
 #include "default_client_buffer_stream_factory.h"
+#include "make_protobuf_object.h"
 #include "mir_toolkit/mir_platform_message.h"
 #include "mir/client_platform.h"
 #include "mir/client_platform_factory.h"
@@ -106,7 +107,13 @@
         server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
         debug(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
         logger(conf.the_logger()),
+        void_response{mcl::make_protobuf_object<mir::protobuf::Void>()},
+        connect_result{mcl::make_protobuf_object<mir::protobuf::Connection>()},
         connect_done{false},
+        ignored{mcl::make_protobuf_object<mir::protobuf::Void>()},
+        connect_parameters{mcl::make_protobuf_object<mir::protobuf::ConnectParameters>()},
+        platform_operation_reply{mcl::make_protobuf_object<mir::protobuf::PlatformOperationMessage>()},
+        display_configuration_response{mcl::make_protobuf_object<mir::protobuf::DisplayConfiguration>()},
         client_platform_factory(conf.the_client_platform_factory()),
         input_platform(conf.the_input_platform()),
         display_configuration(conf.the_display_configuration()),
@@ -115,7 +122,7 @@
         event_handler_register(conf.the_event_handler_register()),
         eventloop{new md::SimpleDispatchThread{std::dynamic_pointer_cast<md::Dispatchable>(channel)}}
 {
-    connect_result.set_error("connect not called");
+    connect_result->set_error("connect not called");
     {
         std::lock_guard<std::mutex> lock(connection_guard);
         next_valid = valid_connections;
@@ -130,9 +137,9 @@
     connect_wait_handle.wait_for_pending(std::chrono::milliseconds(500));
 
     std::lock_guard<decltype(mutex)> lock(mutex);
-    if (connect_result.has_platform())
+    if (connect_result && connect_result->has_platform())
     {
-        auto const& platform = connect_result.platform();
+        auto const& platform = connect_result->platform();
         for (int i = 0, end = platform.fd_size(); i != end; ++i)
             close(platform.fd(i));
     }
@@ -153,9 +160,9 @@
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    if (connect_result.has_error())
+    if (connect_result && connect_result->has_error())
     {
-        return connect_result.error().c_str();
+        return connect_result->error().c_str();
     }
 
     return error_message.c_str();
@@ -202,8 +209,8 @@
 
     SurfaceRelease surf_release{surface, new_wait_handle, callback, context};
 
-    mir::protobuf::SurfaceId message;
-    message.set_value(surface->id());
+    auto message = mcl::make_protobuf_object<mir::protobuf::SurfaceId>();
+    message->set_value(surface->id());
 
     {
         std::lock_guard<decltype(release_wait_handle_guard)> rel_lock(release_wait_handle_guard);
@@ -211,7 +218,7 @@
     }
 
     new_wait_handle->expect_result();
-    server.release_surface(0, &message, &void_response,
+    server.release_surface(0, message.get(), void_response.get(),
                            gp::NewCallback(this, &MirConnection::released, surf_release));
 
 
@@ -230,9 +237,9 @@
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
 
-        if (!connect_result.has_platform() || !connect_result.has_display_configuration())
+        if (!connect_result->has_platform() || !connect_result->has_display_configuration())
         {
-            if (!connect_result.has_error())
+            if (!connect_result->has_error())
             {
                 // We're handling an error scenario that means we're not sync'd
                 // with the client code - a callback isn't safe (or needed)
@@ -263,12 +270,12 @@
 
         platform = client_platform_factory->create_client_platform(this);
         native_display = platform->create_egl_native_display();
-        display_configuration->set_configuration(connect_result.display_configuration());
+        display_configuration->set_configuration(connect_result->display_configuration());
         lifecycle_control->set_lifecycle_event_handler(default_lifecycle_event_handler);
     }
     catch (std::exception const& e)
     {
-        connect_result.set_error(std::string{"Failed to process connect response: "} +
+        connect_result->set_error(std::string{"Failed to process connect response: "} +
                                  boost::diagnostic_information(e));
     }
 
@@ -284,14 +291,14 @@
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
 
-        connect_parameters.set_application_name(app_name);
+        connect_parameters->set_application_name(app_name);
         connect_wait_handle.expect_result();
     }
 
     server.connect(
         0,
-        &connect_parameters,
-        &connect_result,
+        connect_parameters.get(),
+        connect_result.get(),
         google::protobuf::NewCallback(
             this, &MirConnection::connected, callback, context));
     return &connect_wait_handle;
@@ -319,7 +326,7 @@
         disconnecting = true;
     }
     disconnect_wait_handle.expect_result();
-    server.disconnect(0, &ignored, &ignored,
+    server.disconnect(0, ignored.get(), ignored.get(),
                       google::protobuf::NewCallback(this, &MirConnection::done_disconnect));
 
     return &disconnect_wait_handle;
@@ -328,19 +335,19 @@
 void MirConnection::done_platform_operation(
     mir_platform_operation_callback callback, void* context)
 {
-    auto reply = mir_platform_message_create(platform_operation_reply.opcode());
+    auto reply = mir_platform_message_create(platform_operation_reply->opcode());
 
-    set_error_message(platform_operation_reply.error());
+    set_error_message(platform_operation_reply->error());
 
     mir_platform_message_set_data(
         reply,
-        platform_operation_reply.data().data(),
-        platform_operation_reply.data().size());
+        platform_operation_reply->data().data(),
+        platform_operation_reply->data().size());
 
     mir_platform_message_set_fds(
         reply,
-        platform_operation_reply.fd().data(),
-        platform_operation_reply.fd().size());
+        platform_operation_reply->fd().data(),
+        platform_operation_reply->fd().size());
 
     callback(this, reply, context);
 
@@ -359,21 +366,21 @@
         return nullptr;
     }
 
-    mir::protobuf::PlatformOperationMessage protobuf_request;
+    auto protobuf_request = mcl::make_protobuf_object<mir::protobuf::PlatformOperationMessage>();
 
-    protobuf_request.set_opcode(mir_platform_message_get_opcode(request));
+    protobuf_request->set_opcode(mir_platform_message_get_opcode(request));
     auto const request_data = mir_platform_message_get_data(request);
     auto const request_fds = mir_platform_message_get_fds(request);
 
-    protobuf_request.set_data(request_data.data, request_data.size);
+    protobuf_request->set_data(request_data.data, request_data.size);
     for (size_t i = 0; i != request_fds.num_fds; ++i)
-        protobuf_request.add_fd(request_fds.fds[i]);
+        protobuf_request->add_fd(request_fds.fds[i]);
 
     platform_operation_wait_handle.expect_result();
     server.platform_operation(
         0,
-        &protobuf_request,
-        &platform_operation_reply,
+        protobuf_request.get(),
+        platform_operation_reply.get(),
         google::protobuf::NewCallback(this, &MirConnection::done_platform_operation,
                                       callback, context));
 
@@ -391,7 +398,7 @@
             {
                 lock.unlock();
                 std::lock_guard<decltype(connection->mutex)> lock(connection->mutex);
-                return !connection->connect_result.has_error();
+                return !connection->connect_result->has_error();
             }
         }
     }
@@ -407,9 +414,9 @@
 {
     // connect_result is write-once: once it's valid, we don't need to lock
     // to use it.
-    if (connect_done && !connect_result.has_error() && connect_result.has_platform())
+    if (connect_done && !connect_result->has_error() && connect_result->has_platform())
     {
-        auto const& platform = connect_result.platform();
+        auto const& platform = connect_result->platform();
 
         platform_package.data_items = platform.data_size();
         for (int i = 0; i != platform.data_size(); ++i)
@@ -440,15 +447,15 @@
     valid_formats = 0;
 
     std::lock_guard<decltype(mutex)> lock(mutex);
-    if (!connect_result.has_error())
+    if (!connect_result->has_error())
     {
         valid_formats = std::min(
-            static_cast<unsigned int>(connect_result.surface_pixel_format_size()),
+            static_cast<unsigned int>(connect_result->surface_pixel_format_size()),
             formats_size);
 
         for (auto i = 0u; i < valid_formats; i++)
         {
-            formats[i] = static_cast<MirPixelFormat>(connect_result.surface_pixel_format(i));
+            formats[i] = static_cast<MirPixelFormat>(connect_result->surface_pixel_format(i));
         }
     }
 }
@@ -518,10 +525,10 @@
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    set_error_message(display_configuration_response.error());
+    set_error_message(display_configuration_response->error());
 
-    if (!display_configuration_response.has_error())
-        display_configuration->set_configuration(display_configuration_response);
+    if (!display_configuration_response->has_error())
+        display_configuration->set_configuration(*display_configuration_response);
 
     return configure_display_wait_handle.result_received();
 }
@@ -533,14 +540,14 @@
         return NULL;
     }
 
-    mir::protobuf::DisplayConfiguration request;
+    auto request = mcl::make_protobuf_object<mir::protobuf::DisplayConfiguration>();
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
 
         for (auto i=0u; i < config->num_outputs; i++)
         {
             auto output = config->outputs[i];
-            auto display_request = request.add_display_output();
+            auto display_request = request->add_display_output();
             display_request->set_output_id(output.output_id);
             display_request->set_used(output.used);
             display_request->set_current_mode(output.current_mode);
@@ -553,7 +560,7 @@
     }
 
     configure_display_wait_handle.expect_result();
-    server.configure_display(0, &request, &display_configuration_response,
+    server.configure_display(0, request.get(), display_configuration_response.get(),
         google::protobuf::NewCallback(this, &MirConnection::done_display_configure));
 
     return &configure_display_wait_handle;
 
=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2015-03-31 02:35:42 +0000
+++ src/client/mir_connection.h	2015-06-17 19:19:38 +0000
@@ -36,6 +36,8 @@
 
 #include "mir_wait_handle.h"
 
+#include <memory>
+
 namespace mir
 {
 class SharedLibrary;
@@ -156,13 +158,13 @@
     mir::protobuf::DisplayServer::Stub server;
     mir::protobuf::Debug::Stub debug;
     std::shared_ptr<mir::logging::Logger> const logger;
-    mir::protobuf::Void void_response;
-    mir::protobuf::Connection connect_result;
+    std::unique_ptr<mir::protobuf::Void> void_response;
+    std::unique_ptr<mir::protobuf::Connection> connect_result;
     std::atomic<bool> connect_done;
-    mir::protobuf::Void ignored;
-    mir::protobuf::ConnectParameters connect_parameters;
-    mir::protobuf::PlatformOperationMessage platform_operation_reply;
-    mir::protobuf::DisplayConfiguration display_configuration_response;
+    std::unique_ptr<mir::protobuf::Void> ignored;
+    std::unique_ptr<mir::protobuf::ConnectParameters> connect_parameters;
+    std::unique_ptr<mir::protobuf::PlatformOperationMessage> platform_operation_reply;
+    std::unique_ptr<mir::protobuf::DisplayConfiguration> display_configuration_response;
     std::atomic<bool> disconnecting{false};
 
     std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
 
=== modified file 'src/client/mir_prompt_session.cpp'
--- src/client/mir_prompt_session.cpp	2015-03-31 02:35:42 +0000
+++ src/client/mir_prompt_session.cpp	2015-06-17 19:19:38 +0000
@@ -18,6 +18,7 @@
 
 #include "mir_prompt_session.h"
 #include "event_handler_register.h"
+#include "make_protobuf_object.h"
 
 namespace mp = mir::protobuf;
 namespace mcl = mir::client;
@@ -26,6 +27,10 @@
     mp::DisplayServer& server,
     std::shared_ptr<mcl::EventHandlerRegister> const& event_handler_register) :
     server(server),
+    parameters(mcl::make_protobuf_object<mir::protobuf::PromptSessionParameters>()),
+    add_result(mcl::make_protobuf_object<mir::protobuf::Void>()),
+    protobuf_void(mcl::make_protobuf_object<mir::protobuf::Void>()),
+    socket_fd_response(mcl::make_protobuf_object<mir::protobuf::SocketFD>()),
     event_handler_register(event_handler_register),
     event_handler_register_id{event_handler_register->register_event_handler(
         [this](MirEvent const& event)
@@ -34,6 +39,7 @@
                 set_state(mir_prompt_session_event_get_state(mir_event_get_prompt_session_event(&event)));
         })},
     state(mir_prompt_session_state_stopped),
+    session(mcl::make_protobuf_object<mir::protobuf::Void>()),
     handle_prompt_session_state_change{[](MirPromptSessionState){}}
 {
 }
@@ -64,14 +70,14 @@
 {
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
-        parameters.set_application_pid(application_pid);
+        parameters->set_application_pid(application_pid);
     }
 
     start_wait_handle.expect_result();
     server.start_prompt_session(
         0,
-        &parameters,
-        &session,
+        parameters.get(),
+        session.get(),
         google::protobuf::NewCallback(this, &MirPromptSession::done_start,
                                       callback, context));
 
@@ -84,8 +90,8 @@
 
     server.stop_prompt_session(
         0,
-        &protobuf_void,
-        &protobuf_void,
+        protobuf_void.get(),
+        protobuf_void.get(),
         google::protobuf::NewCallback(this, &MirPromptSession::done_stop,
                                       callback, context));
 
@@ -110,7 +116,7 @@
     {
         std::lock_guard<decltype(session_mutex)> lock(session_mutex);
 
-        state = session.has_error() ? mir_prompt_session_state_stopped : mir_prompt_session_state_started;
+        state = session->has_error() ? mir_prompt_session_state_stopped : mir_prompt_session_state_started;
     }
 
     callback(this, context);
@@ -129,10 +135,10 @@
 {
     std::lock_guard<decltype(session_mutex)> lock(session_mutex);
 
-    if (!session.has_error())
-        session.set_error(std::string{});
+    if (!session->has_error())
+        session->set_error(std::string{});
 
-    return session.error().c_str();
+    return session->error().c_str();
 }
 
 MirWaitHandle* MirPromptSession::new_fds_for_prompt_providers(
@@ -140,15 +146,15 @@
     mir_client_fd_callback callback,
     void * context)
 {
-    mir::protobuf::SocketFDRequest request;
-    request.set_number(no_of_fds);
+    auto request = mcl::make_protobuf_object<mir::protobuf::SocketFDRequest>();
+    request->set_number(no_of_fds);
 
     fds_for_prompt_providers_wait_handle.expect_result();
 
     server.new_fds_for_prompt_providers(
         nullptr,
-        &request,
-        &socket_fd_response,
+        request.get(),
+        socket_fd_response.get(),
         google::protobuf::NewCallback(this, &MirPromptSession::done_fds_for_prompt_providers,
                                               callback, context));
 
@@ -159,13 +165,13 @@
     mir_client_fd_callback callback,
     void* context)
 {
-    auto const size = socket_fd_response.fd_size();
+    auto const size = socket_fd_response->fd_size();
 
     std::vector<int> fds;
     fds.reserve(size);
 
     for (auto i = 0; i != size; ++i)
-        fds.push_back(socket_fd_response.fd(i));
+        fds.push_back(socket_fd_response->fd(i));
 
     callback(this, size, fds.data(), context);
     fds_for_prompt_providers_wait_handle.result_received();
 
=== modified file 'src/client/mir_prompt_session.h'
--- src/client/mir_prompt_session.h	2015-01-21 07:34:50 +0000
+++ src/client/mir_prompt_session.h	2015-06-17 19:19:38 +0000
@@ -60,10 +60,10 @@
 private:
     std::mutex mutable mutex; // Protects parameters, wait_handles & results
     mir::protobuf::DisplayServer& server;
-    mir::protobuf::PromptSessionParameters parameters;
-    mir::protobuf::Void add_result;
-    mir::protobuf::Void protobuf_void;
-    mir::protobuf::SocketFD socket_fd_response;
+    std::unique_ptr<mir::protobuf::PromptSessionParameters> parameters;
+    std::unique_ptr<mir::protobuf::Void> add_result;
+    std::unique_ptr<mir::protobuf::Void> protobuf_void;
+    std::unique_ptr<mir::protobuf::SocketFD> socket_fd_response;
     std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
     int const event_handler_register_id;
 
@@ -73,7 +73,7 @@
     std::atomic<MirPromptSessionState> state;
 
     std::mutex mutable session_mutex; // Protects session
-    mir::protobuf::Void session;
+    std::unique_ptr<mir::protobuf::Void> session;
 
     std::mutex mutable event_handler_mutex; // Need another mutex for callback access to members
     std::function<void(MirPromptSessionState)> handle_prompt_session_state_change;
 
=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2015-04-25 11:38:31 +0000
+++ src/client/mir_screencast.cpp	2015-06-17 19:19:38 +0000
@@ -18,6 +18,7 @@
 
 #include "mir_screencast.h"
 #include "client_buffer_stream_factory.h"
+#include "make_protobuf_object.h"
 #include "client_buffer_stream.h"
 #include "mir/frontend/client_constants.h"
 #include "mir_toolkit/mir_native_buffer.h"
@@ -38,7 +39,9 @@
     mir_screencast_callback callback, void* context)
     : server(server),
       output_size{size},
-      buffer_stream_factory{buffer_stream_factory}
+      buffer_stream_factory{buffer_stream_factory},
+      protobuf_screencast{mcl::make_protobuf_object<mir::protobuf::Screencast>()},
+      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()}
 {
     if (output_size.width.as_int()  == 0 ||
         output_size.height.as_int() == 0 ||
@@ -48,23 +51,23 @@
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
     }
-    protobuf_screencast.set_error("Not initialized");
-
-    mir::protobuf::ScreencastParameters parameters;
-
-    parameters.mutable_region()->set_left(region.top_left.x.as_int());
-    parameters.mutable_region()->set_top(region.top_left.y.as_int());
-    parameters.mutable_region()->set_width(region.size.width.as_uint32_t());
-    parameters.mutable_region()->set_height(region.size.height.as_uint32_t());
-    parameters.set_width(output_size.width.as_uint32_t());
-    parameters.set_height(output_size.height.as_uint32_t());
-    parameters.set_pixel_format(pixel_format);
+    protobuf_screencast->set_error("Not initialized");
+
+    auto parameters = mcl::make_protobuf_object<mir::protobuf::ScreencastParameters>();
+
+    parameters->mutable_region()->set_left(region.top_left.x.as_int());
+    parameters->mutable_region()->set_top(region.top_left.y.as_int());
+    parameters->mutable_region()->set_width(region.size.width.as_uint32_t());
+    parameters->mutable_region()->set_height(region.size.height.as_uint32_t());
+    parameters->set_width(output_size.width.as_uint32_t());
+    parameters->set_height(output_size.height.as_uint32_t());
+    parameters->set_pixel_format(pixel_format);
 
     create_screencast_wait_handle.expect_result();
     server.create_screencast(
         nullptr,
-        &parameters,
-        &protobuf_screencast,
+        parameters.get(),
+        protobuf_screencast.get(),
         google::protobuf::NewCallback(
             this, &MirScreencast::screencast_created,
             callback, context));
@@ -77,20 +80,20 @@
 
 bool MirScreencast::valid()
 {
-    return !protobuf_screencast.has_error();
+    return !protobuf_screencast->has_error();
 }
 
 MirWaitHandle* MirScreencast::release(
         mir_screencast_callback callback, void* context)
 {
-    mir::protobuf::ScreencastId screencast_id;
-    screencast_id.set_value(protobuf_screencast.screencast_id().value());
+    auto screencast_id = mcl::make_protobuf_object<mir::protobuf::ScreencastId>();
+    screencast_id->set_value(protobuf_screencast->screencast_id().value());
     
     release_wait_handle.expect_result();
     server.release_screencast(
         nullptr,
-        &screencast_id,
-        &protobuf_void,
+        screencast_id.get(),
+        protobuf_void.get(),
         google::protobuf::NewCallback(
             this, &MirScreencast::released, callback, context));
 
@@ -104,10 +107,10 @@
 void MirScreencast::screencast_created(
     mir_screencast_callback callback, void* context)
 {
-    if (!protobuf_screencast.has_error())
+    if (!protobuf_screencast->has_error())
     {
         buffer_stream = buffer_stream_factory->make_consumer_stream(server,
-            protobuf_screencast.buffer_stream(), "MirScreencast");
+            protobuf_screencast->buffer_stream(), "MirScreencast");
     }
 
     callback(this, context);
 
=== modified file 'src/client/mir_screencast.h'
--- src/client/mir_screencast.h	2015-03-31 02:35:42 +0000
+++ src/client/mir_screencast.h	2015-06-17 19:19:38 +0000
@@ -27,6 +27,8 @@
 
 #include <EGL/eglplatform.h>
 
+#include <memory>
+
 namespace mir
 {
 namespace protobuf { class DisplayServer; }
@@ -72,8 +74,8 @@
     
     std::shared_ptr<mir::client::ClientBufferStream> buffer_stream;
 
-    mir::protobuf::Screencast protobuf_screencast;
-    mir::protobuf::Void protobuf_void;
+    std::unique_ptr<mir::protobuf::Screencast> protobuf_screencast;
+    std::unique_ptr<mir::protobuf::Void> protobuf_void;
 
     MirWaitHandle create_screencast_wait_handle;
     MirWaitHandle release_wait_handle;
 
=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2015-04-28 10:30:44 +0000
+++ src/client/mir_surface.cpp	2015-06-17 19:19:38 +0000
@@ -16,12 +16,13 @@
  * Authored by: Thomas Guest <[e-mail]>
  */
 
+#include "mir_surface.h"
+#include "cursor_configuration.h"
+#include "client_buffer_stream_factory.h"
+#include "make_protobuf_object.h"
 #include "mir_toolkit/mir_client_library.h"
 #include "mir/frontend/client_constants.h"
 #include "mir/client_buffer.h"
-#include "mir_surface.h"
-#include "cursor_configuration.h"
-#include "client_buffer_stream_factory.h"
 #include "mir_connection.h"
 #include "mir/dispatch/simple_dispatch_thread.h"
 #include "mir/input/input_platform.h"
@@ -41,7 +42,7 @@
 
 #define SERIALIZE_OPTION_IF_SET(option, message) \
     if (option.is_set()) \
-        message.set_##option(option.value());
+        message->set_##option(option.value());
 
 namespace
 {
@@ -78,9 +79,9 @@
 {
 }
 
-mir::protobuf::SurfaceParameters MirSurfaceSpec::serialize() const
+std::unique_ptr<mir::protobuf::SurfaceParameters> MirSurfaceSpec::serialize() const
 {
-    mir::protobuf::SurfaceParameters message;
+    auto message = mcl::make_protobuf_object<mp::SurfaceParameters>();
 
     SERIALIZE_OPTION_IF_SET(width, message);
     SERIALIZE_OPTION_IF_SET(height, message);
@@ -102,34 +103,35 @@
     // max_aspect is a special case (below)
 
     if (parent.is_set() && parent.value() != nullptr)
-        message.set_parent_id(parent.value()->id());
+        message->set_parent_id(parent.value()->id());
 
     if (aux_rect.is_set())
     {
-        message.mutable_aux_rect()->set_left(aux_rect.value().left);
-        message.mutable_aux_rect()->set_top(aux_rect.value().top);
-        message.mutable_aux_rect()->set_width(aux_rect.value().width);
-        message.mutable_aux_rect()->set_height(aux_rect.value().height);
+        message->mutable_aux_rect()->set_left(aux_rect.value().left);
+        message->mutable_aux_rect()->set_top(aux_rect.value().top);
+        message->mutable_aux_rect()->set_width(aux_rect.value().width);
+        message->mutable_aux_rect()->set_height(aux_rect.value().height);
     }
 
     if (min_aspect.is_set())
     {
-        message.mutable_min_aspect()->set_width(min_aspect.value().width);
-        message.mutable_min_aspect()->set_height(min_aspect.value().height);
+        message->mutable_min_aspect()->set_width(min_aspect.value().width);
+        message->mutable_min_aspect()->set_height(min_aspect.value().height);
     }
 
     if (max_aspect.is_set())
     {
-        message.mutable_max_aspect()->set_width(max_aspect.value().width);
-        message.mutable_max_aspect()->set_height(max_aspect.value().height);
+        message->mutable_max_aspect()->set_width(max_aspect.value().width);
+        message->mutable_max_aspect()->set_height(max_aspect.value().height);
     }
 
     return message;
 }
 
 MirSurface::MirSurface(std::string const& error)
+    : surface{mcl::make_protobuf_object<mir::protobuf::Surface>()}
 {
-    surface.set_error(error);
+    surface->set_error(error);
 
     std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
     valid_surfaces.insert(this);
@@ -145,11 +147,16 @@
     mir_surface_callback callback, void * context)
     : server{&the_server},
       debug{debug},
+      surface{mcl::make_protobuf_object<mir::protobuf::Surface>()},
+      buffer_request{mcl::make_protobuf_object<mir::protobuf::BufferRequest>()},
       name{spec.surface_name.value()},
+      void_response{mcl::make_protobuf_object<mir::protobuf::Void>()},
+      modify_result{mcl::make_protobuf_object<mir::protobuf::Void>()},
       connection(allocating_connection),
       buffer_stream_factory(buffer_stream_factory),
       input_platform(input_platform),
-      keymapper(std::make_shared<mircv::XKBMapper>())
+      keymapper(std::make_shared<mircv::XKBMapper>()),
+      configure_result{mcl::make_protobuf_object<mir::protobuf::SurfaceSetting>()}
 {
     for (int i = 0; i < mir_surface_attribs; i++)
         attrib_cache[i] = -1;
@@ -158,11 +165,11 @@
     create_wait_handle.expect_result();
     try 
     {
-        server->create_surface(0, &message, &surface, gp::NewCallback(this, &MirSurface::created, callback, context));
+        server->create_surface(0, message.get(), surface.get(), gp::NewCallback(this, &MirSurface::created, callback, context));
     }
     catch (std::exception const& ex)
     {
-        surface.set_error(std::string{"Error invoking create surface: "} +
+        surface->set_error(std::string{"Error invoking create surface: "} +
                           boost::diagnostic_information(ex));
     }
 
@@ -181,8 +188,8 @@
 
     input_thread.reset();
 
-    for (auto i = 0, end = surface.fd_size(); i != end; ++i)
-        close(surface.fd(i));
+    for (auto i = 0, end = surface->fd_size(); i != end; ++i)
+        close(surface->fd(i));
 }
 
 MirSurfaceParameters MirSurface::get_parameters() const
@@ -196,9 +203,9 @@
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    if (surface.has_error())
+    if (surface->has_error())
     {
-        return surface.error().c_str();
+        return surface->error().c_str();
     }
     return error_message.c_str();
 }
@@ -207,7 +214,7 @@
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    return surface.id().value();
+    return surface->id().value();
 }
 
 bool MirSurface::is_valid(MirSurface* query)
@@ -215,7 +222,7 @@
     std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
 
     if (valid_surfaces.count(query))
-        return !query->surface.has_error();
+        return !query->surface->has_error();
 
     return false;
 }
@@ -236,10 +243,10 @@
 {
     {
     std::lock_guard<decltype(mutex)> lock(mutex);
-    if (!surface.has_id())
+    if (!surface->has_id())
     {
-        if (!surface.has_error())
-            surface.set_error("Error processing surface create response, no ID (disconnected?)");
+        if (!surface->has_error())
+            surface->set_error("Error processing surface create response, no ID (disconnected?)");
 
         callback(this, context);
         create_wait_handle.result_received();
@@ -252,11 +259,11 @@
             std::lock_guard<decltype(mutex)> lock(mutex);
 
             buffer_stream = buffer_stream_factory->
-                make_producer_stream(*server, surface.buffer_stream(), name);
+                make_producer_stream(*server, surface->buffer_stream(), name);
 
-            for(int i = 0; i < surface.attributes_size(); i++)
+            for(int i = 0; i < surface->attributes_size(); i++)
             {
-                auto const& attrib = surface.attributes(i);
+                auto const& attrib = surface->attributes(i);
                 attrib_cache[attrib.attrib()] = attrib.ivalue();
             }
         }
@@ -265,7 +272,7 @@
     }
     catch (std::exception const& error)
     {
-        surface.set_error(std::string{"Error processing Surface creating response:"} +
+        surface->set_error(std::string{"Error processing Surface creating response:"} +
                           boost::diagnostic_information(error));
     }
 
@@ -284,7 +291,7 @@
             was_valid = true;
         valid_surfaces.erase(this);
     }
-    if (this->surface.has_error())
+    if (this->surface->has_error())
         was_valid = false;
 
     MirWaitHandle* wait_handle{nullptr};
@@ -303,29 +310,28 @@
 
 MirWaitHandle* MirSurface::configure_cursor(MirCursorConfiguration const* cursor)
 {
-    mp::CursorSetting setting;
+    auto setting = mcl::make_protobuf_object<mp::CursorSetting>();
 
     {
         std::unique_lock<decltype(mutex)> lock(mutex);
-        setting.mutable_surfaceid()->CopyFrom(surface.id());
+        setting->mutable_surfaceid()->CopyFrom(surface->id());
         if (cursor)
         {
             if (cursor->stream != nullptr)
             {
-                setting.mutable_buffer_stream()->set_value(cursor->stream->rpc_id().as_value());
-                setting.set_hotspot_x(cursor->hotspot_x);
-                setting.set_hotspot_y(cursor->hotspot_y);
+                setting->mutable_buffer_stream()->set_value(cursor->stream->rpc_id().as_value());
+                setting->set_hotspot_x(cursor->hotspot_x);
+                setting->set_hotspot_y(cursor->hotspot_y);
             }
             else if (cursor->name != mir_disabled_cursor_name)
             {
-                setting.set_name(cursor->name.c_str());
+                setting->set_name(cursor->name.c_str());
             }
-
         }
     }
     
     configure_cursor_wait_handle.expect_result();
-    server->configure_cursor(0, &setting, &void_response,
+    server->configure_cursor(0, setting.get(), void_response.get(),
         google::protobuf::NewCallback(this, &MirSurface::on_cursor_configured));
     
     return &configure_cursor_wait_handle;
@@ -345,14 +351,14 @@
 
     std::unique_lock<decltype(mutex)> lock(mutex);
 
-    mp::SurfaceSetting setting;
-    setting.mutable_surfaceid()->CopyFrom(surface.id());
-    setting.set_attrib(at);
-    setting.set_ivalue(value);
+    auto setting = mcl::make_protobuf_object<mp::SurfaceSetting>();
+    setting->mutable_surfaceid()->CopyFrom(surface->id());
+    setting->set_attrib(at);
+    setting->set_ivalue(value);
     lock.unlock();
 
     configure_wait_handle.expect_result();
-    server->configure_surface(0, &setting, &configure_result,
+    server->configure_surface(0, setting.get(), configure_result.get(),
               google::protobuf::NewCallback(this, &MirSurface::on_configured));
 
     return &configure_wait_handle;
@@ -374,12 +380,12 @@
         return false;
     }
 
-    mp::CoordinateTranslationRequest request;
+    auto request = mcl::make_protobuf_object<mp::CoordinateTranslationRequest>();
 
-    request.set_x(x);
-    request.set_y(y);
-    *request.mutable_surfaceid() = surface.id();
-    mp::CoordinateTranslationResponse response;
+    request->set_x(x);
+    request->set_y(y);
+    *request->mutable_surfaceid() = surface->id();
+    auto response = mcl::make_protobuf_object<mp::CoordinateTranslationResponse>();
 
     MirWaitHandle signal;
     signal.expect_result();
@@ -389,27 +395,27 @@
 
         debug->translate_surface_to_screen(
             nullptr,
-            &request,
-            &response,
+            request.get(),
+            response.get(),
             google::protobuf::NewCallback(&signal_response_received, &signal));
     }
 
     signal.wait_for_one();
 
-    *screen_x = response.x();
-    *screen_y = response.y();
-    return !response.has_error();
+    *screen_x = response->x();
+    *screen_y = response->y();
+    return !response->has_error();
 }
 
 void MirSurface::on_configured()
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    if (configure_result.has_surfaceid() &&
-        configure_result.surfaceid().value() == surface.id().value() &&
-        configure_result.has_attrib())
+    if (configure_result->has_surfaceid() &&
+        configure_result->surfaceid().value() == surface->id().value() &&
+        configure_result->has_attrib())
     {
-        int a = configure_result.attrib();
+        int a = configure_result->attrib();
 
         switch (a)
         {
@@ -418,10 +424,10 @@
         case mir_surface_attrib_focus:
         case mir_surface_attrib_dpi:
         case mir_surface_attrib_preferred_orientation:
-            if (configure_result.has_ivalue())
-                attrib_cache[a] = configure_result.ivalue();
+            if (configure_result->has_ivalue())
+                attrib_cache[a] = configure_result->ivalue();
             else
-                assert(configure_result.has_error());
+                assert(configure_result->has_error());
             break;
         default:
             assert(false);
@@ -466,9 +472,9 @@
                                           std::placeholders::_1,
                                           context);
 
-        if (surface.fd_size() > 0 && handle_event_callback)
+        if (surface->fd_size() > 0 && handle_event_callback)
         {
-            auto input_dispatcher = input_platform->create_input_receiver(surface.fd(0),
+            auto input_dispatcher = input_platform->create_input_receiver(surface->fd(0),
                                                                           keymapper,
                                                                           handle_event_callback);
             input_thread = std::make_shared<md::SimpleDispatchThread>(input_dispatcher);
@@ -540,7 +546,7 @@
 {
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
-        if (modify_result.has_error())
+        if (modify_result->has_error())
         {
             // TODO return errors like lp:~vanvugt/mir/wait-result
         }
@@ -550,14 +556,14 @@
 
 MirWaitHandle* MirSurface::modify(MirSurfaceSpec const& spec)
 {
-    mp::SurfaceModifications mods;
+    auto mods = mcl::make_protobuf_object<mp::SurfaceModifications>();
 
     {
         std::unique_lock<decltype(mutex)> lock(mutex);
-        mods.mutable_surface_id()->set_value(surface.id().value());
+        mods->mutable_surface_id()->set_value(surface->id().value());
     }
 
-    auto const surface_specification = mods.mutable_surface_specification();
+    auto const surface_specification = mods->mutable_surface_specification();
 
     #define COPY_IF_SET(field)\
         if (spec.field.is_set())\
@@ -619,7 +625,7 @@
     }
 
     modify_wait_handle.expect_result();
-    server->modify_surface(0, &mods, &modify_result,
+    server->modify_surface(0, mods.get(), modify_result.get(),
               google::protobuf::NewCallback(this, &MirSurface::on_modified));
 
     return &modify_wait_handle;
 
=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2015-04-28 08:59:22 +0000
+++ src/client/mir_surface.h	2015-06-17 19:19:38 +0000
@@ -65,7 +65,7 @@
     MirSurfaceSpec(MirConnection* connection, int width, int height, MirPixelFormat format);
     MirSurfaceSpec(MirConnection* connection, MirSurfaceParameters const& params);
 
-    mir::protobuf::SurfaceParameters serialize() const;
+    std::unique_ptr<mir::protobuf::SurfaceParameters> serialize() const;
 
     struct AspectRatio { unsigned width; unsigned height; };
 
@@ -163,15 +163,15 @@
 
     mir::protobuf::DisplayServer::Stub* server{nullptr};
     mir::protobuf::Debug::Stub* debug{nullptr};
-    mir::protobuf::Surface surface;
-    mir::protobuf::BufferRequest buffer_request;
+    std::unique_ptr<mir::protobuf::Surface> surface;
+    std::unique_ptr<mir::protobuf::BufferRequest> buffer_request;
     std::string error_message;
     std::string name;
-    mir::protobuf::Void void_response;
+    std::unique_ptr<mir::protobuf::Void> void_response;
 
     void on_modified();
     MirWaitHandle modify_wait_handle;
-    mir::protobuf::Void modify_result;
+    std::unique_ptr<mir::protobuf::Void> modify_result;
 
     MirConnection* const connection{nullptr};
 
@@ -184,7 +184,7 @@
     std::shared_ptr<mir::input::receiver::InputPlatform> const input_platform;
     std::shared_ptr<mir::input::receiver::XKBMapper> const keymapper;
 
-    mir::protobuf::SurfaceSetting configure_result;
+    std::unique_ptr<mir::protobuf::SurfaceSetting> configure_result;
 
     // Cache of latest SurfaceSettings returned from the server
     int attrib_cache[mir_surface_attribs];
 
=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2015-04-25 11:38:31 +0000
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2015-06-17 19:19:38 +0000
@@ -25,6 +25,7 @@
 #include "../display_configuration.h"
 #include "../lifecycle_control.h"
 #include "../event_sink.h"
+#include "../make_protobuf_object.h"
 #include "mir/variable_length_array.h"
 #include "mir/events/event_private.h"
 
@@ -233,24 +234,24 @@
 
 void mclr::MirProtobufRpcChannel::process_event_sequence(std::string const& event)
 {
-    mir::protobuf::EventSequence seq;
-
-    seq.ParseFromString(event);
-
-    if (seq.has_display_configuration())
-    {
-        display_configuration->update_configuration(seq.display_configuration());
-    }
-
-    if (seq.has_lifecycle_event())
-    {
-        lifecycle_control->call_lifecycle_event_handler(seq.lifecycle_event().new_state());
-    }
-
-    int const nevents = seq.event_size();
+    auto seq = mcl::make_protobuf_object<mir::protobuf::EventSequence>();
+
+    seq->ParseFromString(event);
+
+    if (seq->has_display_configuration())
+    {
+        display_configuration->update_configuration(seq->display_configuration());
+    }
+
+    if (seq->has_lifecycle_event())
+    {
+        lifecycle_control->call_lifecycle_event_handler(seq->lifecycle_event().new_state());
+    }
+
+    int const nevents = seq->event_size();
     for (int i = 0; i != nevents; ++i)
     {
-        mir::protobuf::Event const& event = seq.event(i);
+        mir::protobuf::Event const& event = seq->event(i);
         if (event.has_raw())
         {
             std::string const& raw_event = event.raw();
@@ -317,7 +318,7 @@
      */
     std::lock_guard<decltype(read_mutex)> lock(read_mutex);
 
-    mir::protobuf::wire::Result result;
+    auto result = mcl::make_protobuf_object<mir::protobuf::wire::Result>();
     try
     {
         uint16_t message_size;
@@ -327,9 +328,9 @@
         body_bytes.resize(message_size);
         transport->receive_data(body_bytes.data(), message_size);
 
-        result.ParseFromArray(body_bytes.data(), message_size);
+        result->ParseFromArray(body_bytes.data(), message_size);
 
-        rpc_report->result_receipt_succeeded(result);
+        rpc_report->result_receipt_succeeded(*result);
     }
     catch (std::exception const& x)
     {
@@ -339,14 +340,14 @@
 
     try
     {
-        for (int i = 0; i != result.events_size(); ++i)
+        for (int i = 0; i != result->events_size(); ++i)
         {
-            process_event_sequence(result.events(i));
+            process_event_sequence(result->events(i));
         }
 
-        if (result.has_id())
+        if (result->has_id())
         {
-            pending_calls.complete_response(result);
+            pending_calls.complete_response(*result);
         }
     }
     catch (std::exception const& x)
@@ -354,7 +355,7 @@
         // TODO: This is dangerous as an error in result processing could cause a wait handle
         // to never fire. Could perhaps fix by catching and setting error on the response before invoking
         // callback ~racarr
-        rpc_report->result_processing_failed(result, x);
+        rpc_report->result_processing_failed(*result, x);
     }
 }