Mir

Merge lp:~brandontschaefer/mir/mir-event-capnproto into lp:mir

mir-event-capnproto
Merge into development-branch

Proposed by Brandon Schaefer on 2016-04-01

Status:	Superseded
Proposed branch:	lp:~brandontschaefer/mir/mir-event-capnproto
Merge into:	lp:mir
Prerequisite:	lp:~brandontschaefer/mir/class-ify-mir-events
Diff against target:	4172 lines (+1169/-995) 59 files modified CMakeLists.txt (+2/-1) debian/control (+2/-0) include/client/mir/events/event_builders.h (+1/-7) include/client/mir_toolkit/events/input_device_state_event.h (+14/-0) include/test/mir/test/event_matchers.h (+7/-2) src/CMakeLists.txt (+1/-0) src/capnproto/CMakeLists.txt (+29/-0) src/capnproto/mir_event.capnp (+237/-0) src/client/event.cpp (+216/-52) src/client/event_printer.cpp (+4/-4) src/client/events/event_builders.cpp (+8/-33) src/client/input/input_event.cpp (+118/-30) src/client/mir_cookie.cpp (+10/-9) src/client/mir_cookie.h (+6/-4) src/client/mir_surface.cpp (+1/-1) src/client/symbols.map (+1/-0) src/common/CMakeLists.txt (+3/-1) src/common/events/CMakeLists.txt (+3/-0) src/common/events/close_surface_event.cpp (+4/-4) src/common/events/event.cpp (+75/-111) src/common/events/input_configuration_event.cpp (+8/-8) src/common/events/input_device_state_event.cpp (+46/-131) src/common/events/input_event.cpp (+0/-5) src/common/events/keyboard_event.cpp (+31/-26) src/common/events/keymap_event.cpp (+11/-113) src/common/events/motion_event.cpp (+93/-108) src/common/events/orientation_event.cpp (+6/-6) src/common/events/prompt_session_event.cpp (+4/-4) src/common/events/resize_event.cpp (+8/-8) src/common/events/surface_event.cpp (+8/-8) src/common/events/surface_output_event.cpp (+12/-12) src/common/events/surface_placement_event.cpp (+11/-6) src/common/symbols.map (+6/-4) src/include/common/mir/events/close_surface_event.h (+0/-3) src/include/common/mir/events/event.h (+21/-62) src/include/common/mir/events/input_configuration_event.h (+0/-6) src/include/common/mir/events/input_device_state_event.h (+8/-25) src/include/common/mir/events/input_event.h (+0/-1) src/include/common/mir/events/keyboard_event.h (+3/-15) src/include/common/mir/events/keymap_event.h (+0/-18) src/include/common/mir/events/motion_event.h (+4/-40) src/include/common/mir/events/orientation_event.h (+0/-4) src/include/common/mir/events/prompt_session_event.h (+0/-3) src/include/common/mir/events/resize_event.h (+0/-5) src/include/common/mir/events/surface_event.h (+0/-5) src/include/common/mir/events/surface_output_event.h (+0/-8) src/server/graphics/nested/input_platform.cpp (+7/-3) src/server/input/android/input_sender.cpp (+24/-5) src/server/input/default_event_builder.cpp (+1/-3) src/server/input/key_repeat_dispatcher.cpp (+1/-3) src/server/input/validator.cpp (+3/-4) tests/unit-tests/client/input/test_android_input_receiver.cpp (+1/-1) tests/unit-tests/input/android/test_android_input_sender.cpp (+9/-5) tests/unit-tests/input/test_event_builders.cpp (+20/-9) tests/unit-tests/input/test_surface_input_dispatcher.cpp (+1/-1) tests/unit-tests/input/test_validator.cpp (+34/-34) tests/unit-tests/scene/test_application_session.cpp (+39/-25) tests/unit-tests/scene/test_surface.cpp (+2/-2) tests/unit-tests/scene/test_surface_impl.cpp (+5/-7)
To merge this branch:	bzr merge lp:~brandontschaefer/mir/mir-event-capnproto
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Needs Fixing on 2016-04-29
Andreas Pokorny (community)			Approve on 2016-04-20
Chris Halse Rogers			Approve on 2016-04-20
Alan Griffiths			Approve on 2016-04-13
Daniel van Vugt			Abstain on 2016-04-13
Cemil Azizoglu (community)		2016-04-01	Needs Fixing on 2016-04-04
Review via email: mp+290760@code.launchpad.net

This proposal has been superseded by a proposal from 2016-09-19.

Commit message

Switch to using capnproto for the MirEvents. Long term will be making a capnptoro input sender/recevier using the capnproto serialization.

Description of the change

Moves to support capnproto as how MirEvents are handled under the hood.

The main idea of capnproto is a union for a pool of memory. You can only ever deep copy the arena pool of memory. Otherwise you've to re-init and change the values.

The asReader() (ie. Reader) class is the ReadOnly class for the structure. Its the only way to get const functions. Otherwise they will be non-const functions.

ie.

event.asReader().getXXX() == CONST
event.getXXX() == Returns modifiable structures

There is a current hack in place to keep a pointers lifetime for as long as the event. This should be removed once we can remove this from the public API: mir_input_device_state_event_device_pressed_keys()

Anpok mentions its not actually used yet? It would just be an API break but if no one uses it *shouldnt* be an issue to remove but I have a workaround atm.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-01:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-04:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-04-04:

Need to do more thorough review... For now :

s/MotionEventSet/MotionSetEvent
279 + motionSet @1 :MotionEventSet;

review: Needs Fixing

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-04-06:

+ BOOST_THROW_EXCEPTION(std::runtime_error("Unknown type, major error"));

The message won't be helpful - what was the "Unknown type"? And who is "major error"?

review: Needs Fixing

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-06:

@Cemil

Yeah sounds better

@Alan

It was one of those errors... that shouldnt ever happen. I suppose it should just say Unknown event type, and thats about all

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-06:

Also, please feel free to suggest any names anywhere. This would be a good time to change names of things!

I've changed:

MotionEvent --> MotionSetEvet
MotionPointer --> Motion
pointer_coord --> motions
pointer_count --> count

Soo any more are welcome!

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-06:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-04-07:

I'm still looking at the same line of code!

+ BOOST_THROW_EXCEPTION(std::runtime_error("Unknown event type"));

Now this is in MirEvent::type() - and that is called from mir_event_get_input_event() which is part of the C API.

We all know that we must not propagate exceptions though C code.

So, something is wrong here. Actually, probably multiple things:

1. mir_event_get_input_event() is missing a function try block.
2. The error should be fatal, not reported by an exception

I've not checked the other exceptions, but suspect this isn't an isolated case.

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-08:

It makes no sense to change the names of structures that mismatch our needs.

I mean Motion is abused for pointer and touch screen events.. So actually Motion is a bunch of TouchContacts with contact id, x, y, action, major minor orientation and pressure and a contact type (and as far as I can tell you wont need a size here .. ) . There should be no source id - just device id. The source id information is exposed via the input device api. Also you then need a Pointer event with x, y, dx, dy, hscroll_ticks and vscroll_ticks.. (and later double scroll values for better touchpad scrolling)

How hard would it be to fix the code generator of capnproto to accept and emit mir style code?

review: Needs Information

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-08:

@Alan

Yeah I missed all those this branch... I had them for the last branch.

Ill print a message then abort there, vs throwing.

@Andreas

Sadly: https://github.com/sandstorm-io/capnproto/issues/164

I just couldnt think of a better name really :(. So you're proposing we split this *Motion* structure into two structures 1 for touch the other for pointer? Or just keep what we have now rename, and include only contact id, x, y, action, major, minor, orientation, pressure, contact type, dx, dy, hscroll/vscroll?

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-08:

I assumed you intend to fix the MirEvent structures in a later mp - and this is just another one on one mapping MP of what we had, with no intention to consolidate it. So I expected another MP changing the types to match what we actually try to represent with the event API. To finally get rid of all the mapping code for input events.

But If this is meant to reflect the intended end state then this is a needs fixing..

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-08:

This is indeed how i saw the end state of the event API mainly because its how its currently reflected.

If we want to change how it looks... then lets, Im just not 100% sure how your view of the end state is :).

Sooo we can try to do a hangout and talk about what is here vs what we should look like!

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-11:

I think we do not need the InputConfigurationEvent, but it is in our client API now. We might as well keep it. We will send updated input configuration structures as soon as the configuration changes, which might be enough to indicate configuration events.

Things I changed:
- dumped all pointer related elements from Contact
- moved Action into Contact (yay finally no more need to duplicate touch events)
- dumped size which is directly derived from major/minor
- added input event that holds the input event properties
- added a real pointer event with all the axis we expose and the ones we should be able expose soon..

If one cannot have regular properties and an unnamed union inside the same structure, one could use an intermediate structure inside InputEvent that then containd the union of input events.

+struct NanoSeconds
+{
+ count @0 :Int64;
+}
+
+struct InputDeviceId
+{
+ id @0 :UInt64;
+}
+
+struct KeyboardEvent
+{
+ action @0 :Action;
+ keyCode @1 :Int32;
+ scanCode @2 :Int32;
+
+ enum Action
+ {
+ up @0;
+ down @1;
+ repeat @2;
+ }
+}
+
+struct TouchEvent
+{
+ struct Contact
+ {
+ id @0 :Int32;
+ action @1: Action;
+ x @2 :Float32;
+ y @3 :Float32;
+ majorAxis @4 :Float32;
+ minorAxis @5 :Float32;
+ pressure @6 :Float32;
+ orientation @7 :Float32; // not yet exposed
+ toolType @8 :ToolType;
+
+ enum ToolType
+ {
+ unknown @0;
+ finger @1;
+ stylus @2;
+ }
+ enum Action
+ {
+ up @0;
+ down @1;
+ change @2;
+ }
+ }
+
+ deviceId @0 :InputDeviceId;
+ modifiers @1 :UInt32;
+ eventTime @2 :NanoSeconds;
+ cookie @3 :Data;
+
+ count @4 :UInt32;
+ contacts @5 :List(Contact);
+ const maxCount :UInt32 = 16; // do we need that?
+}
+
+struct PointerEvent
+{
+ action @0 :Action;
+ x @1 :Float32;
+ y @2 :Float32;
+ dx @3 :Float32;
+ dy @4 :Float32;
+ hscrollTicks @5 :Float32;
+ vscrollTicks @6 :Float32;
+ hscrollMotion @7 :Float32; // not yet exposed
+ vscrollMotion @8 :Float32; // not yet exposed
+ enum Action
+ {
+ up @0;
+ down @1;
+ enter @2;
+ leave @3;
+ motion @4;
+ };
+}
+
+struct InputEvent
+{
+ deviceId @0 :InputDeviceId;
+ modifiers @1 :UInt32;
+ eventTime @2 :NanoSeconds;
+ cookie @3 :Data;
+ union
+ {
+ keyboard @0 :KeyboardEvent;
+ touch @1 :TouchEvent;
+ pointer @2 :PointerEvent;
+ }
}
+
+ ... snip ...
+
+struct Event
+{
+ union
+ {
+ input @0 :InputEvent;
+ surface @1 :SurfaceEvent;
+ resize @2 :ResizeEvent;
.... snip ...
+ }
+}

Things I changed:
 - dumped all pointer related elements from Contact
 - moved Action into Contact (yay finally no more need to duplicate touch events)
 - dumped size which is directly derived from major/minor
 - added input event that holds the input event properties
 - added a real pointer event with all the axis we expose and the ones we should be able expose soon..

If one cannot have regular properties and an unnamed union inside the same structure, one could use an intermediate structure inside InputEvent that then containd the union of input events.

+struct NanoSeconds
+{
+    count @0 :Int64;
+}
+
+struct InputDeviceId
+{
+    id @0 :UInt64;
+}
+
+struct KeyboardEvent
+{
+    action @0 :Action;
+    keyCode @1 :Int32;
+    scanCode @2 :Int32;
+
+    enum Action
+    {
+        up @0;
+        down @1;
+        repeat @2;
+    }
+}
+
+struct TouchEvent
+{
+    struct Contact
+    {
+        id @0 :Int32;
+        action @1: Action;
+        x @2 :Float32;
+        y @3 :Float32;
+        majorAxis @4 :Float32;
+        minorAxis @5 :Float32;
+        pressure @6 :Float32;
+        orientation @7 :Float32;  // not yet exposed
+        toolType @8 :ToolType;
+
+        enum ToolType
+        {
+            unknown @0;
+            finger @1;
+            stylus @2;
+        }
+        enum Action
+        {
+            up @0;
+            down @1;
+            change @2;
+        }    
+    }
+
+    deviceId @0 :InputDeviceId;
+    modifiers @1 :UInt32;
+    eventTime @2 :NanoSeconds;
+    cookie @3 :Data;
+
+    count @4 :UInt32;
+    contacts @5 :List(Contact);
+    const maxCount :UInt32 = 16; // do we need that?
+}
+
+struct PointerEvent
+{
+    action @0 :Action;
+    x @1 :Float32;
+    y @2 :Float32;
+    dx @3 :Float32;
+    dy @4 :Float32;
+    hscrollTicks @5 :Float32;
+    vscrollTicks @6 :Float32;
+    hscrollMotion @7 :Float32; // not yet exposed
+    vscrollMotion @8 :Float32; // not yet exposed
+    enum Action
+    { 
+        up @0;
+        down @1;
+        enter @2;
+        leave @3;
+        motion @4;
+    };
+}
+
+struct InputEvent
+{
+    deviceId @0 :InputDeviceId;
+    modifiers @1 :UInt32;
+    eventTime @2 :NanoSeconds;
+    cookie @3 :Data;
+    union
+    {
+        keyboard @0 :KeyboardEvent;
+        touch @1 :TouchEvent;
+        pointer @2 :PointerEvent;
+    }
}
+
+ ... snip ... 
+
+struct Event
+{
+    union
+    {
+        input @0 :InputEvent;
+        surface @1 :SurfaceEvent;
+        resize @2 :ResizeEvent;
.... snip ...
+    }
+}

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-11:

@Andreas

I like those changes, and I can make a new branch after this one to add that in. Main reason not to in this branch, is i can see that adding +/- 1k lines.

Soo yes now this branch is not the final form :)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-11:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-11:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-04-12:

The numbers are erratic, but it looks like this new code is slower than Protobuf under stress. Is that expected?...

$ mirping -f

(this branch)
Round-trip time: 0.044031 milliseconds
Round-trip time: 0.044160 milliseconds
Round-trip time: 0.044155 milliseconds
Round-trip time: 0.044229 milliseconds
Round-trip time: 0.044130 milliseconds
Round-trip time: 0.044168 milliseconds

(lp:mir)
Round-trip time: 0.038198 milliseconds
Round-trip time: 0.038178 milliseconds
Round-trip time: 0.037950 milliseconds
Round-trip time: 0.038150 milliseconds
Round-trip time: 0.037935 milliseconds
Round-trip time: 0.038156 milliseconds
Round-trip time: 0.038351 milliseconds

review: Needs Information

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-04-12:

+} catch (...)
+{
+ abort();
}

Is this the intended end state? It might assist users encountering this if we at least output the string from the exception before aborting.

Also, the figures Daniel provides are concerning. I thought one motivation for Capnproto was performance.

review: Needs Information

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-12:

@Duflu

Hmm this ... doesnt replace any protobuf stuff? The only bits that touch protobuf are:

std::string MirEvent::serialize(MirEvent const* event)
and
mir::EventUPtr MirEvent::deserialize(std::string const& bytes)

Which are only used for Surface events. Thats all we touch with protobuf, from there its just replacing android directly blitting over an FD (hard to be as fast as that). Though we copy them back into android events for now.

The solution for the serialize/deserialize is to simply move those into actual protobuf structres for now. That'll make it so capnproto does not touch anything that protobuf uses

@Alan
Yeah i can print out the error message to the log!

The number one reason (as far as I know) for capnproto was to get a actual serialization into events to handle keymap/cookies better. Also its a first implementation, I could have caused some slow downs in those two functions. From my testing at lease we are faster with capnproto (when we replace the actual sender/receiver)

The other issue is we have to copy from capnproto --> android event --> fd (client) --> capnproto again. So yes, this is going to be slower on that front until we merge the sender/receiver code for capnproto. Which is done but needs to be tested a bit more. Mainly in the re-sampling areas.

You can test this branch out which has the capnproto input platform:
https://code.launchpad.net/~brandontschaefer/mir/canproto-input-platform

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-12:

Also you'll notice that that branch will still be the same for RPC. The overall issue is having to use capnproto to produce *serialized* bytes to send of protobuf, when protobuf should really be handling that for us... So yes the side effect for right now is a slower RPC when it comes to surface events, but the reason capnproto is slower here is because we are slightly abusing it to get it to work

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-04-13:

OK. It isn't really a blocking issue yet. Just keep 'mirping -f' in mind because in the long run if performance is still worse then we need to reassess this approach.

Even a few years ago it was apparent that the Mir protocol created a performance handicap compared to Wayland. So making it even slower again would be a red flag.

review: Abstain

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-04-13:

I'd be happier if we addressed two concerns before releasing this:

1. the performance issue
2. eating potentially useful error information

But I'm willing to let this land provided solutions to the above to follow shortly.

review: Approve

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-13:

Opps forgot to push #2!

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-13:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-19:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-19:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-19:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-04-20:

1384 + for (auto const& c : flat_event.asBytes())
1385 + {
1386 + output += c;
1387 + }

Is it really necessary to do this a character at a time? You'll almost certainly be incurring a couple of unnecessary memory allocations here.

1415 + case mir::capnp::Event::Which::SURFACE_OUTPUT:
1416 + return mir_event_type_surface_output;
1417 + }
1418 +
1419 + mir::log_critical("unknown event type.");
1420 + abort();

Wouldn't the idiomatic thing here be to have a default: stanza in the switch()?

Otherwise, seems pretty sensible (modulo already requested follow-up work)

review: Approve

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-04-20:

yeah those could be simple std::string(begin(flat_event), end(flat_event)) constructor calls.

I am looking forward to the upcoming MPs

review: Approve

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-20:

Fixed.

I look forward to that branch as well :).

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-20:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-20:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Brandon Schaefer (brandontschaefer) wrote on 2016-04-20:

Yay cant reproduce that test issue ... seems to happen on xenial and vivid overlay....

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-21:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-04-29:

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

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Brandon Schaefer

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-09-08 16:52:49 +0000
 +++ CMakeLists.txt	2016-09-18 20:00:37 +0000
@@ -196,6 +196,7 @@
  find_package(GLESv2 REQUIRED)
  find_package(GLM REQUIRED)
  find_package(Protobuf REQUIRED )
++find_package(CapnProto REQUIRED)
  find_package(GLog REQUIRED)
  find_package(GFlags REQUIRED)
  find_package(LTTngUST REQUIRED)
@@ -293,7 +294,7 @@
    # There's no nice way to format this. Thanks CMake.
    mir_add_test(NAME LGPL-required
--    COMMAND /bin/sh -c "! grep -rl 'GNU General' ${PROJECT_SOURCE_DIR}/src/client ${PROJECT_SOURCE_DIR}/include/client ${PROJECT_SOURCE_DIR}/src/common ${PROJECT_SOURCE_DIR}/include/common ${PROJECT_SOURCE_DIR}/src/include/common ${PROJECT_SOURCE_DIR}/src/platform ${PROJECT_SOURCE_DIR}/include/platform ${PROJECT_SOURCE_DIR}/src/include/platform"
++    COMMAND /bin/sh -c "! grep -rl 'GNU General' ${PROJECT_SOURCE_DIR}/src/client ${PROJECT_SOURCE_DIR}/include/client ${PROJECT_SOURCE_DIR}/src/common ${PROJECT_SOURCE_DIR}/include/common ${PROJECT_SOURCE_DIR}/src/include/common ${PROJECT_SOURCE_DIR}/src/platform ${PROJECT_SOURCE_DIR}/include/platform ${PROJECT_SOURCE_DIR}/src/include/platform ${PROJECT_SOURCE_DIR}/src/capnproto"
+   )
    mir_add_test(NAME GPL-required
      COMMAND /bin/sh -c "! grep -rl 'GNU Lesser' ${PROJECT_SOURCE_DIR}/src/server ${PROJECT_SOURCE_DIR}/include/server ${PROJECT_SOURCE_DIR}/src/include/server ${PROJECT_SOURCE_DIR}/tests ${PROJECT_SOURCE_DIR}/examples"
 === modified file 'debian/control'
 --- debian/control	2016-09-12 11:49:12 +0000
 +++ debian/control	2016-09-18 20:00:37 +0000
@@ -46,6 +46,8 @@
                 python3:any,
                 dh-python,
                 nettle-dev,
++               libcapnp-dev,
++               capnproto
                 libepoxy-dev,
  Standards-Version: 3.9.4
  Homepage: https://launchpad.net/mir
 === modified file 'include/client/mir/events/event_builders.h'
 --- include/client/mir/events/event_builders.h	2016-09-16 15:18:36 +0000
 +++ include/client/mir/events/event_builders.h	2016-09-18 20:00:37 +0000
@@ -25,6 +25,7 @@
  #include "mir/geometry/point.h"
  #include "mir/geometry/rectangle.h"
  #include "mir/frontend/surface_id.h"
++#include "mir/events/input_device_state.h"
  #include <memory>
  #include <functional>
@@ -138,13 +139,6 @@
  EventUPtr make_event(MirInputConfigurationAction action,
      MirInputDeviceId id, std::chrono::nanoseconds time);
--struct InputDeviceState
--{
--    MirInputDeviceId id;
--    std::vector<uint32_t> pressed_keys;
--    MirPointerButtons buttons;
--};
--
  EventUPtr make_event(std::chrono::nanoseconds timestamp,
                       MirPointerButtons pointer_buttons,
                       MirInputEventModifiers modifiers,
 === modified file 'include/client/mir_toolkit/events/input_device_state_event.h'
 --- include/client/mir_toolkit/events/input_device_state_event.h	2016-06-02 15:07:12 +0000
 +++ include/client/mir_toolkit/events/input_device_state_event.h	2016-09-18 20:00:37 +0000
@@ -100,14 +100,28 @@
   * Retrieve an array of pressed keys on the device identified by the \a index.
   * The keys are encoded as scan codes.
+  *
++ * \deprecated  Use mir_input_device_state_event_device_pressed_keys_for_index() instead
   * \param[in] ev The input device state event
   * \param[in] index The index of the input device
   * \return    An array of pressed keys
   */
++__attribute__ ((deprecated))
  uint32_t const* mir_input_device_state_event_device_pressed_keys(
      MirInputDeviceStateEvent const* ev, uint32_t index);
  /**
++ * Retrieve a pressed key on the device identified by the \a index.
++ * The key is encoded as a scan code.
++ *
++ * \param[in] ev            The input device state event
++ * \param[in] index         The index of the input device
++ * \param[in] pressed_index The index of the pressed key
++ * \return    The pressed key at index pressed_index
++ */
++uint32_t mir_input_device_state_event_device_pressed_keys_for_index(
++    MirInputDeviceStateEvent const* ev, uint32_t index, uint32_t pressed_index);
++
++/**
   * Retrieve the size of scan code array of the device identified by the \a index.
+  *
   * \param[in] ev The input device state event
 === modified file 'include/test/mir/test/event_matchers.h'
 --- include/test/mir/test/event_matchers.h	2016-07-04 12:17:44 +0000
 +++ include/test/mir/test/event_matchers.h	2016-09-18 20:00:37 +0000
@@ -527,8 +527,13 @@
          if (num_required_keys != key_count)
              continue;
--        auto pressed_keys = mir_input_device_state_event_device_pressed_keys(device_state, index);
--        if (!std::equal(it_keys, end_keys, pressed_keys))
++        std::vector<uint32_t> pressed_keys;
++        for (uint32_t i = 0; i < key_count; i++)
++        {
++            pressed_keys.push_back(mir_input_device_state_event_device_pressed_keys_for_index(device_state, index, i));
++        }
++
++        if (!std::equal(it_keys, end_keys, std::begin(pressed_keys)))
              continue;
          return true;
+     }
 === modified file 'src/CMakeLists.txt'
 --- src/CMakeLists.txt	2016-08-01 14:43:19 +0000
 +++ src/CMakeLists.txt	2016-09-18 20:00:37 +0000
@@ -16,6 +16,7 @@
  # the src/include/... directories should be private to the implementation
  include_directories(${PROJECT_SOURCE_DIR}/src/include/common)
  set(MIR_GENERATED_INCLUDE_DIRECTORIES)
++add_subdirectory(capnproto/)
  add_subdirectory(common/)
  add_subdirectory(protobuf/)
  include_directories(${MIR_GENERATED_INCLUDE_DIRECTORIES})
 === added directory 'src/capnproto'
 === added file 'src/capnproto/CMakeLists.txt'
 --- src/capnproto/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/capnproto/CMakeLists.txt	2016-09-18 20:00:37 +0000
@@ -0,0 +1,29 @@
++# Copyright © 2016 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/>.
++#
++# Author: Brandon Schaefer <brandon.schaefer@canonical.com>
++
++set(CAPNPC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
++
++capnp_generate_cpp(CAPNPROTO_SRC CAPNPROTO_HDRS mir_event.capnp)
++
++add_library(mircapnproto STATIC ${CAPNPROTO_SRC})
++target_link_libraries(mircapnproto ${CAPNP_LIBRARIES_LITE})
++
++list(APPEND MIR_GENERATED_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_BINARY_DIR})
++
++set(
++  MIR_GENERATED_INCLUDE_DIRECTORIES ${MIR_GENERATED_INCLUDE_DIRECTORIES}
++  PARENT_SCOPE
++)
 === added file 'src/capnproto/mir_event.capnp'
 --- src/capnproto/mir_event.capnp	1970-01-01 00:00:00 +0000
 +++ src/capnproto/mir_event.capnp	2016-09-18 20:00:37 +0000
@@ -0,0 +1,237 @@
++# Copyright © 2016 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/>.
++#
++# Author: Brandon Schaefer <brandon.schaefer@canonical.com>
++
++@0x9ff9e89b8e11dc56;
++
++# Need to namespace the InputEvent/Event since the generated (Mir)Event has all its ctors deleted.
++# Which we need a C compliant struct to be generated. So namespace these, and wrap a
++# builder in a struct MirEvent {..};
++using Cxx = import "/capnp/c++.capnp";
++$Cxx.namespace("mir::capnp");
++
++struct NanoSeconds
++{
++    count @0 :Int64;
++}
++
++struct InputDeviceId
++{
++    id @0 :UInt64;
++}
++
++struct Rectangle
++{
++    left @0 :Int32;
++    top @1 :Int32;
++    width @2 :UInt32;
++    height @3 :UInt32;
++}
++
++struct KeyboardEvent
++{
++    id @0 :Int32;
++    deviceId @1 :InputDeviceId;
++    sourceId @2 :Int32;
++    action @3 :Action;
++    modifiers @4 :UInt32;
++    keyCode @5 :Int32;
++    scanCode @6 :Int32;
++    eventTime @7 :NanoSeconds;
++    cookie @8 :Data;
++
++    enum Action
++    {
++        up @0;
++        down @1;
++        repeat @2;
++    }
++}
++
++struct MotionSetEvent
++{
++    struct Motion
++    {
++        id @0 :Int32;
++        x @1 :Float32;
++        y @2 :Float32;
++        dx @3 :Float32;
++        dy @4 :Float32;
++        touchMajor @5 :Float32;
++        touchMinor @6 :Float32;
++        size @7 :Float32;
++        pressure @8 :Float32;
++        orientation @9 :Float32;
++        vscroll @10 :Float32;
++        hscroll @11 :Float32;
++
++        toolType @12 :ToolType;
++
++        # TODO: We would like to store this as a TouchAction but we still encode pointer actions
++        # here as well.
++        action @13 :Int32;
++
++        enum ToolType
++        {
++            unknown @0;
++            finger @1;
++            stylus @2;
++        }
++    }
++
++    deviceId @0 :InputDeviceId;
++    sourceId @1 :Int32;
++    modifiers @2 :UInt32;
++    buttons @3 :UInt32;
++    eventTime @4 :NanoSeconds;
++    cookie @5 :Data;
++
++    count @6 :UInt32;
++    motions @7 :List(Motion);
++    const maxCount :UInt32 = 16;
++}
++
++struct InputConfigurationEvent
++{
++    action @0 :Action;
++    when @1 :NanoSeconds;
++    id @2 :InputDeviceId;
++
++    enum Action
++    {
++        configurationChanged @0;
++        deviceReset @1;
++    }
++}
++
++struct SurfaceEvent
++{
++    id @0 :Int32;
++    attrib @1 :Attrib;
++    value @2 :Int32;
++
++    enum Attrib
++    {
++        # Do not specify values...code relies on 0...N ordering.
++        type @0;
++        state @1;
++        swapInterval @2;
++        focus @3;
++        dpi @4;
++        visibility @5;
++        preferredOrientation @6;
++        # Must be last
++        surfaceAttrib @7;
++    }
++}
++
++struct ResizeEvent
++{
++    surfaceId @0 :Int32;
++    width @1 :Int32;
++    height @2 :Int32;
++}
++
++struct PromptSessionEvent
++{
++    newState @0 :State;
++
++    enum State
++    {
++        stopped @0;
++        started @1;
++        suspended @2;
++    }
++}
++
++struct OrientationEvent
++{
++    surfaceId @0 :Int32;
++    direction @1 :Int32;
++}
++
++struct CloseSurfaceEvent
++{
++    surfaceId @0 :Int32;
++}
++
++struct KeymapEvent
++{
++    surfaceId @0 :Int32;
++
++    deviceId @1 :InputDeviceId;
++    buffer @2 :Text;
++}
++
++struct SurfaceOutputEvent
++{
++    surfaceId @0 :Int32;
++    dpi @1 :Int32;
++    scale @2 :Float32;
++    formFactor @3 :FormFactor;
++    outputId @4 :UInt32;
++
++    enum FormFactor
++    {
++        unknown @0;
++        phone @1;
++        tablet @2;
++        monitor @3;
++        tv @4;
++        projector @5;
++    }
++}
++
++struct InputDeviceStateEvent
++{
++    when @0 :NanoSeconds;
++    buttons @1 :UInt32;
++    modifiers @2 :UInt32;
++    pointerX @3 :Float32;
++    pointerY @4 :Float32;
++    devices @5 :List(DeviceState);
++
++    struct DeviceState
++    {
++        deviceId @0 :InputDeviceId;
++        pressedKeys @1 :List(UInt32);
++        buttons @2 :UInt32;
++    }
++}
++
++struct SurfacePlacementEvent
++{
++    id @0 :Int32;
++    rectangle @1 :Rectangle;
++}
++
++struct Event
++{
++    union
++    {
++        key @0 :KeyboardEvent;
++        motionSet @1 :MotionSetEvent;
++        surface @2 :SurfaceEvent;
++        resize @3 :ResizeEvent;
++        promptSession @4 :PromptSessionEvent;
++        orientation @5 :OrientationEvent;
++        closeSurface @6 :CloseSurfaceEvent;
++        keymap @7 :KeymapEvent;
++        inputConfiguration @8 :InputConfigurationEvent;
++        surfaceOutput @9 :SurfaceOutputEvent;
++        inputDevice @10 :InputDeviceStateEvent;
++        surfacePlacement @11 :SurfacePlacementEvent;
++    }
++}
 === modified file 'src/client/event.cpp'
 --- src/client/event.cpp	2016-09-16 15:18:36 +0000
 +++ src/client/event.cpp	2016-09-18 20:00:37 +0000
@@ -40,7 +40,7 @@
  namespace
+ {
  template <typename EventType>
--void expect_event_type(EventType const* ev, MirEventType t)
++void expect_event_type(EventType const* ev, MirEventType t) try
+ {
      if (ev->type() != t)
+     {
@@ -48,6 +48,10 @@
              mir::event_type_to_string(ev->type()));
          abort();
+     }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  void expect_index_in_range(size_t size, size_t index)
@@ -88,7 +92,7 @@
+ }
--MirEventType mir_event_get_type(MirEvent const* ev)
++MirEventType mir_event_get_type(MirEvent const* ev) try
+ {
      switch (ev->type())
+     {
@@ -98,9 +102,13 @@
      default:
          return ev->type();
+     }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputEvent const* mir_event_get_input_event(MirEvent const* ev)
++MirInputEvent const* mir_event_get_input_event(MirEvent const* ev) try
+ {
      if (ev->type() != mir_event_type_key && ev->type() != mir_event_type_motion)
+     {
@@ -110,236 +118,393 @@
+     }
      return ev->to_input();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* ev)
++MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface);
      return ev->to_surface();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirResizeEvent const* mir_event_get_resize_event(MirEvent const* ev)
++MirResizeEvent const* mir_event_get_resize_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_resize);
      return ev->to_resize();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirPromptSessionEvent const* mir_event_get_prompt_session_event(MirEvent const* ev)
++MirPromptSessionEvent const* mir_event_get_prompt_session_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_prompt_session_state_change);
      return ev->to_prompt_session();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirOrientationEvent const* mir_event_get_orientation_event(MirEvent const* ev)
++MirOrientationEvent const* mir_event_get_orientation_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_orientation);
      return ev->to_orientation();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirCloseSurfaceEvent const* mir_event_get_close_surface_event(MirEvent const* ev)
++MirCloseSurfaceEvent const* mir_event_get_close_surface_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_close_surface);
      return ev->to_close_surface();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirKeymapEvent const* mir_event_get_keymap_event(MirEvent const* ev)
++MirKeymapEvent const* mir_event_get_keymap_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_keymap);
      return ev->to_keymap();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* ev)
++MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_configuration);
      return ev->to_input_configuration();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev)
++MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface_output);
      return ev->to_surface_output();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputDeviceStateEvent const* mir_event_get_input_device_state_event(MirEvent const* ev)
++MirInputDeviceStateEvent const* mir_event_get_input_device_state_event(MirEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->to_input_device_state();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Surface event accessors */
--MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev)
++MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface);
      return ev->attrib();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int mir_surface_event_get_attribute_value(MirSurfaceEvent const* ev)
++int mir_surface_event_get_attribute_value(MirSurfaceEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface);
      return ev->value();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Resize event accessors */
--int mir_resize_event_get_width(MirResizeEvent const* ev)
++int mir_resize_event_get_width(MirResizeEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_resize);
      return ev->width();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int mir_resize_event_get_height(MirResizeEvent const* ev)
++int mir_resize_event_get_height(MirResizeEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_resize);
      return ev->height();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Prompt session event accessors */
--MirPromptSessionState mir_prompt_session_event_get_state(MirPromptSessionEvent const* ev)
++MirPromptSessionState mir_prompt_session_event_get_state(MirPromptSessionEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_prompt_session_state_change);
      return ev->new_state();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Orientation event accessors */
--MirOrientation mir_orientation_event_get_direction(MirOrientationEvent const* ev)
++MirOrientation mir_orientation_event_get_direction(MirOrientationEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_orientation);
      return ev->direction();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Keymap event accessors */
--void mir_keymap_event_get_keymap_buffer(MirKeymapEvent const* ev, char const** buffer, size_t* length)
++void mir_keymap_event_get_keymap_buffer(MirKeymapEvent const* ev, char const** buffer, size_t* length) try
+ {
      expect_event_type(ev, mir_event_type_keymap);
      *buffer = ev->buffer();
      *length = ev->size();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputDeviceId mir_keymap_event_get_device_id(MirKeymapEvent const* ev)
++MirInputDeviceId mir_keymap_event_get_device_id(MirKeymapEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_keymap);
      return ev->device_id();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Input configuration event accessors */
--MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* ev)
++MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_configuration);
      return ev->action();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* ev)
++int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_configuration);
      return ev->when().count();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* ev)
++MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_configuration);
      return ev->id();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Surface output event accessors */
--int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev)
++int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface_output);
      return ev->dpi();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev)
++MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface_output);
      return ev->form_factor();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev)
++float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_surface_output);
      return ev->scale();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const *ev)
++uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const *ev) try
+ {
      expect_event_type(ev, mir_event_type_surface_output);
      return ev->output_id();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirPointerButtons mir_input_device_state_event_pointer_buttons(MirInputDeviceStateEvent const* ev)
++MirPointerButtons mir_input_device_state_event_pointer_buttons(MirInputDeviceStateEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->pointer_buttons();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--float mir_input_device_state_event_pointer_axis(MirInputDeviceStateEvent const* ev, MirPointerAxis axis)
++float mir_input_device_state_event_pointer_axis(MirInputDeviceStateEvent const* ev, MirPointerAxis axis) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->pointer_axis(axis);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int64_t mir_input_device_state_event_time(MirInputDeviceStateEvent const* ev)
++int64_t mir_input_device_state_event_time(MirInputDeviceStateEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->when().count();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputEventModifiers mir_input_device_state_event_modifiers(MirInputDeviceStateEvent const* ev)
++MirInputEventModifiers mir_input_device_state_event_modifiers(MirInputDeviceStateEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->modifiers();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--uint32_t mir_input_device_state_event_device_count(MirInputDeviceStateEvent const* ev)
++uint32_t mir_input_device_state_event_device_count(MirInputDeviceStateEvent const* ev) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      return ev->device_count();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputDeviceId mir_input_device_state_event_device_id(MirInputDeviceStateEvent const* ev, uint32_t index)
++MirInputDeviceId mir_input_device_state_event_device_id(MirInputDeviceStateEvent const* ev, uint32_t index) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      expect_index_in_range(ev->device_count(), index);
      return ev->device_id(index);
--}
--
--uint32_t const* mir_input_device_state_event_device_pressed_keys(MirInputDeviceStateEvent const* ev, uint32_t index)
--{
--    expect_event_type(ev, mir_event_type_input_device_state);
--    expect_index_in_range(ev->device_count(), index);
--    return ev->device_pressed_keys(index);
--}
--
--uint32_t mir_input_device_state_event_device_pressed_keys_count(MirInputDeviceStateEvent const* ev, uint32_t index)
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
++}
++
++uint32_t const* mir_input_device_state_event_device_pressed_keys(MirInputDeviceStateEvent const* ev, uint32_t index) try
++{
++    expect_event_type(ev, mir_event_type_input_device_state);
++    expect_index_in_range(ev->device_count(), index);
++
++    auto pressed_keys_vec = const_cast<MirInputDeviceStateEvent*>(ev)->device_pressed_keys(index);
++    auto stored_pointer   = std::shared_ptr<uint32_t>(
++        new uint32_t[pressed_keys_vec.size()],
++        [](uint32_t const* p)
++            { delete[] p; });
++
++    std::copy(std::begin(pressed_keys_vec), std::end(pressed_keys_vec), stored_pointer.get());
++
++    return static_cast<uint32_t*>(mir::event::store_data_for_lifetime_of_event(ev, stored_pointer));
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
++}
++
++uint32_t mir_input_device_state_event_device_pressed_keys_for_index(
++    MirInputDeviceStateEvent const* ev, uint32_t index, uint32_t pressed_index) try
++{
++    expect_event_type(ev, mir_event_type_input_device_state);
++    expect_index_in_range(ev->device_count(), index);
++    return ev->device_pressed_keys_for_index(index, pressed_index);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
++}
++
++uint32_t mir_input_device_state_event_device_pressed_keys_count(MirInputDeviceStateEvent const* ev, uint32_t index) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      expect_index_in_range(ev->device_count(), index);
      return ev->device_pressed_keys_count(index);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirPointerButtons mir_input_device_state_event_device_pointer_buttons(MirInputDeviceStateEvent const* ev, uint32_t index)
++MirPointerButtons mir_input_device_state_event_device_pointer_buttons(MirInputDeviceStateEvent const* ev, uint32_t index) try
+ {
      expect_event_type(ev, mir_event_type_input_device_state);
      expect_index_in_range(ev->device_count(), index);
      return ev->device_pointer_buttons(index);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  MirSurfacePlacementEvent const* mir_event_get_surface_placement_event(MirEvent const* event)
@@ -354,17 +519,16 @@
  // TODO: Until we opaquify the MirEvent structure and add
  // a ref count ref is implemented as copy.
--MirEvent const* mir_event_ref(MirEvent const* ev)
--{
--    return ev->clone();
++MirEvent const* mir_event_ref(MirEvent const* ev) try
++{
++    return new MirEvent(*ev);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  void mir_event_unref(MirEvent const* ev)
+ {
--    if (mir_event_get_type(ev) == mir_event_type_keymap)
--    {
--        const_cast<MirEvent*>(ev)->to_keymap()->free_buffer();
--    }
--
      delete const_cast<MirEvent*>(ev);
+ }
 === modified file 'src/client/event_printer.cpp'
 --- src/client/event_printer.cpp	2016-09-16 15:18:36 +0000
 +++ src/client/event_printer.cpp	2016-09-18 20:00:37 +0000
@@ -348,11 +348,11 @@
          out << mir_input_device_state_event_device_id(&event, index)
              << " btns=" << mir_input_device_state_event_device_pointer_buttons(&event, index)
              << " pressed=(";
--        auto keys = mir_input_device_state_event_device_pressed_keys(&event, index);
--        for (size_t count_keys = mir_input_device_state_event_device_pressed_keys_count(&event, index), i = 0; i != count_keys; ++i)
++        auto key_count = mir_input_device_state_event_device_pressed_keys_count(&event, index);
++        for (uint32_t i = 0; i < key_count; i++)
+         {
--            out << static_cast<uint32_t>(keys[i]);
--            if (i + 1 < count_keys)
++            out << mir_input_device_state_event_device_pressed_keys_for_index(&event, index, i);
++            if (i + 1 < key_count)
                  out << ", ";
+         }
          out << ")";
 === modified file 'src/client/events/event_builders.cpp'
 --- src/client/events/event_builders.cpp	2016-09-16 15:18:36 +0000
 +++ src/client/events/event_builders.cpp	2016-09-18 20:00:37 +0000
@@ -41,22 +41,6 @@
  namespace
+ {
--    mir::cookie::Blob vector_to_cookie_as_blob(std::vector<uint8_t> const& vector)
--    {
--        mir::cookie::Blob blob{{}};
--
--        if (vector.size() > blob.size())
--        {
--            throw std::runtime_error("Vector size " + std::to_string(vector.size()) +
--                                     " is larger then array size: " +
--                                     std::to_string(blob.size()));
--        }
--
--        std::copy_n(vector.begin(), vector.size(), blob.begin());
--
--        return blob;
--    }
--
  template <class T>
  T* new_event()
+ {
@@ -70,7 +54,6 @@
+ {
      return mir::EventUPtr(e, ([](MirEvent* e) { delete reinterpret_cast<T*>(e); }));
+ }
--
+ }
  mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirOrientation orientation)
@@ -195,7 +178,7 @@
      e->set_device_id(device_id);
      e->set_source_id(AINPUT_SOURCE_KEYBOARD);
      e->set_event_time(timestamp);
--    e->set_cookie(vector_to_cookie_as_blob(cookie));
++    e->set_cookie(cookie);
      e->set_action(action);
      e->set_key_code(key_code);
      e->set_scan_code(scan_code);
@@ -269,7 +252,7 @@
      e->set_device_id(device_id);
      e->set_event_time(timestamp);
--    e->set_cookie(vector_to_cookie_as_blob(cookie));
++    e->set_cookie(cookie);
      e->set_modifiers(modifiers);
      e->set_source_id(AINPUT_SOURCE_TOUCHSCREEN);
@@ -321,7 +304,7 @@
      auto& mev = *e->to_input()->to_motion();
      mev.set_device_id(device_id);
      mev.set_event_time(timestamp);
--    mev.set_cookie(vector_to_cookie_as_blob(cookie));
++    mev.set_cookie(cookie);
      mev.set_modifiers(modifiers);
      mev.set_source_id(AINPUT_SOURCE_MOUSE);
      mev.set_buttons(buttons_pressed);
@@ -390,15 +373,7 @@
                                 std::string const& layout, std::string const& variant, std::string const& options)
+ {
      auto e = new_event<MirKeymapEvent>();
--    auto ep = mir::EventUPtr(e, [](MirEvent* e) {
--        // xkbcommon creates the keymap through malloc
--        if (e && e->type() == mir_event_type_keymap)
--        {
--            e->to_keymap()->free_buffer();
--        }
--
--        delete e;
--    });
++    auto ep = make_uptr_event(e);
      auto ctx = mi::make_unique_context();
      auto map = mi::make_unique_keymap(ctx.get(), mi::Keymap{model, layout, variant, options});
@@ -409,8 +384,9 @@
      e->set_surface_id(surface_id.as_value());
      e->set_device_id(id);
      // TODO consider caching compiled keymaps
--    e->set_buffer(xkb_keymap_get_as_string(map.get(), XKB_KEYMAP_FORMAT_TEXT_V1));
--    e->set_size(strlen(e->to_keymap()->buffer()));
++    auto buffer = xkb_keymap_get_as_string(map.get(), XKB_KEYMAP_FORMAT_TEXT_V1);
++    e->set_buffer(buffer);
++    std::free(buffer);
      return ep;
+ }
@@ -439,8 +415,7 @@
      e->set_pointer_buttons(pointer_buttons);
      e->set_pointer_axis(mir_pointer_axis_x, x_axis_value);
      e->set_pointer_axis(mir_pointer_axis_y, y_axis_value);
--    for (auto& dev : device_states)
--        e->add_device(dev.id, std::move(dev.pressed_keys), dev.buttons);
++    e->set_device_states(device_states);
      return make_uptr_event(e);
+ }
 === modified file 'src/client/input/input_event.cpp'
 --- src/client/input/input_event.cpp	2016-08-01 07:44:10 +0000
 +++ src/client/input/input_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,6 +18,9 @@
  #define MIR_LOG_COMPONENT "input-event-access"
++// TODO Remove me once we use capnproto for input platform serialization
++#include "mir/cookie/blob.h"
++
  #include "mir/cookie/cookie.h"
  #include "mir/event_type_to_string.h"
  #include "mir/events/event_private.h"
@@ -91,7 +94,7 @@
+ }
+ }
--MirInputEventType mir_input_event_get_type(MirInputEvent const* ev)
++MirInputEventType mir_input_event_get_type(MirInputEvent const* ev) try
+ {
      if (ev->type() != mir_event_type_key && ev->type() != mir_event_type_motion)
+     {
@@ -108,9 +111,13 @@
      default:
          abort();
+     }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputDeviceId mir_input_event_get_device_id(MirInputEvent const* ev)
++MirInputDeviceId mir_input_event_get_device_id(MirInputEvent const* ev) try
+ {
      if(mir_event_get_type(ev) != mir_event_type_input)
+     {
@@ -127,9 +134,13 @@
      default:
          abort();
+     }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int64_t mir_input_event_get_event_time(MirInputEvent const* ev)
++int64_t mir_input_event_get_event_time(MirInputEvent const* ev) try
+ {
      if(mir_event_get_type(ev) != mir_event_type_input)
+     {
@@ -146,6 +157,10 @@
      default:
          abort();
+     }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  MirInputEvent const* mir_pointer_event_input_event(MirPointerEvent const* event)
@@ -177,33 +192,53 @@
      return reinterpret_cast<MirKeyboardEvent const*>(ev);
+ }
--MirKeyboardAction mir_keyboard_event_action(MirKeyboardEvent const* kev)
++MirKeyboardAction mir_keyboard_event_action(MirKeyboardEvent const* kev) try
+ {
      return kev->action();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--xkb_keysym_t mir_keyboard_event_key_code(MirKeyboardEvent const* kev)
++xkb_keysym_t mir_keyboard_event_key_code(MirKeyboardEvent const* kev) try
+ {
      return kev->key_code();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--int mir_keyboard_event_scan_code(MirKeyboardEvent const* kev)
++int mir_keyboard_event_scan_code(MirKeyboardEvent const* kev) try
+ {
      return kev->scan_code();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputEventModifiers mir_keyboard_event_modifiers(MirKeyboardEvent const* kev)
++MirInputEventModifiers mir_keyboard_event_modifiers(MirKeyboardEvent const* kev) try
+ {
      return kev->modifiers();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  /* Touch event accessors */
--MirInputEventModifiers mir_touch_event_modifiers(MirTouchEvent const* tev)
++MirInputEventModifiers mir_touch_event_modifiers(MirTouchEvent const* tev) try
+ {
      return tev->to_motion()->modifiers();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirTouchEvent const* mir_input_event_get_touch_event(MirInputEvent const* ev)
++MirTouchEvent const* mir_input_event_get_touch_event(MirInputEvent const* ev) try
+ {
      if(mir_input_event_get_type(ev) != mir_input_event_type_touch)
+     {
@@ -213,14 +248,22 @@
+     }
      return reinterpret_cast<MirTouchEvent const*>(ev);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--unsigned int mir_touch_event_point_count(MirTouchEvent const* event)
++unsigned int mir_touch_event_point_count(MirTouchEvent const* event) try
+ {
      return event->to_motion()->pointer_count();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirTouchId mir_touch_event_id(MirTouchEvent const* event, size_t touch_index)
++MirTouchId mir_touch_event_id(MirTouchEvent const* event, size_t touch_index) try
+ {
      if (touch_index >= event->to_motion()->pointer_count())
+     {
@@ -229,9 +272,13 @@
+     }
      return event->to_motion()->id(touch_index);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirTouchAction mir_touch_event_action(MirTouchEvent const* event, size_t touch_index)
++MirTouchAction mir_touch_event_action(MirTouchEvent const* event, size_t touch_index) try
+ {
      if(touch_index > event->to_motion()->pointer_count())
+     {
@@ -240,10 +287,14 @@
+     }
      return static_cast<MirTouchAction>(event->to_motion()->action(touch_index));
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  MirTouchTooltype mir_touch_event_tooltype(MirTouchEvent const* event,
--    size_t touch_index)
++    size_t touch_index) try
+ {
      if(touch_index > event->to_motion()->pointer_count())
+     {
@@ -252,10 +303,14 @@
+     }
      return event->to_motion()->tool_type(touch_index);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  float mir_touch_event_axis_value(MirTouchEvent const* event,
--    size_t touch_index, MirTouchAxis axis)
++    size_t touch_index, MirTouchAxis axis) try
+ {
      if(touch_index > event->to_motion()->pointer_count())
+     {
@@ -281,11 +336,15 @@
      default:
          return -1;
+     }
--}
++}  catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
++}
  /* Pointer event accessors */
--MirPointerEvent const* mir_input_event_get_pointer_event(MirInputEvent const* ev)
++MirPointerEvent const* mir_input_event_get_pointer_event(MirInputEvent const* ev) try
+ {
      if(mir_input_event_get_type(ev) != mir_input_event_type_pointer)
+     {
@@ -295,30 +354,50 @@
+     }
      return reinterpret_cast<MirPointerEvent const*>(ev);
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirInputEventModifiers mir_pointer_event_modifiers(MirPointerEvent const* pev)
++MirInputEventModifiers mir_pointer_event_modifiers(MirPointerEvent const* pev) try
+ {
      return pev->to_motion()->modifiers();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirPointerAction mir_pointer_event_action(MirPointerEvent const* pev)
++MirPointerAction mir_pointer_event_action(MirPointerEvent const* pev) try
+ {
      return static_cast<MirPointerAction>(pev->to_motion()->action(0));
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  bool mir_pointer_event_button_state(MirPointerEvent const* pev,
--    MirPointerButton button)
++    MirPointerButton button) try
+ {
     return pev->to_motion()->buttons() & button;
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--MirPointerButtons mir_pointer_event_buttons(MirPointerEvent const* pev)
++MirPointerButtons mir_pointer_event_buttons(MirPointerEvent const* pev) try
+ {
     return pev->to_motion()->buttons();
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--float mir_pointer_event_axis_value(MirPointerEvent const* pev, MirPointerAxis axis)
++float mir_pointer_event_axis_value(MirPointerEvent const* pev, MirPointerAxis axis) try
+ {
     auto mev = pev->to_motion();
     switch (axis)
@@ -339,9 +418,13 @@
         mir::log_critical("Invalid axis enumeration " + std::to_string(axis));
         abort();
+    }
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
--bool mir_input_event_has_cookie(MirInputEvent const* ev)
++bool mir_input_event_has_cookie(MirInputEvent const* ev) try
+ {
      switch (mir_input_event_get_type(ev))
+     {
@@ -375,13 +458,18 @@
+     }
      return false;
++} catch (std::exception const& e)
++{
++    mir::log_critical(e.what());
++    abort();
+ }
  size_t mir_cookie_buffer_size(MirCookie const* cookie) try
+ {
      return cookie->size();
--} catch (...)
++} catch (std::exception const& e)
+ {
++    mir::log_critical(e.what());
      abort();
+ }
@@ -399,16 +487,18 @@
          abort();
+     }
+     }
--} catch (...)
++} catch (std::exception const& e)
+ {
++    mir::log_critical(e.what());
      abort();
+ }
  void mir_cookie_to_buffer(MirCookie const* cookie, void* buffer, size_t size) try
+ {
      return cookie->copy_to(buffer, size);
--} catch (...)
++} catch (std::exception const& e)
+ {
++    mir::log_critical(e.what());
      abort();
+ }
@@ -418,15 +508,13 @@
          return NULL;
      return new MirCookie(buffer, size);
--} catch (...)
++} catch (std::exception const& e)
+ {
++    mir::log_critical(e.what());
      abort();
+ }
--void mir_cookie_release(MirCookie const* cookie) try
++void mir_cookie_release(MirCookie const* cookie)
+ {
      delete cookie;
--} catch (...)
--{
--    abort();
+ }
 === modified file 'src/client/mir_cookie.cpp'
 --- src/client/mir_cookie.cpp	2016-01-22 20:16:50 +0000
 +++ src/client/mir_cookie.cpp	2016-09-18 20:00:37 +0000
@@ -22,28 +22,29 @@
  #include <string.h>
--MirCookie::MirCookie(void const* buffer, size_t size)
++MirCookie::MirCookie(void const* buffer, size_t size) :
++    cookie_(size)
+ {
--    memcpy(blob_.data(), buffer, size);
++    memcpy(cookie_.data(), buffer, size);
+ }
--MirCookie::MirCookie(mir::cookie::Blob const& blob) :
--    blob_(blob)
++MirCookie::MirCookie(std::vector<uint8_t> const& cookie) :
++    cookie_(cookie)
+ {
+ }
  void MirCookie::copy_to(void* buffer, size_t size) const
+ {
--    mir::require(size == blob_.size());
--    memcpy(buffer, blob_.data(), size);
++    mir::require(size == cookie_.size());
++    memcpy(buffer, cookie_.data(), size);
+ }
  size_t MirCookie::size() const
+ {
--    return blob_.size();
++    return cookie_.size();
+ }
--mir::cookie::Blob MirCookie::blob() const
++std::vector<uint8_t> MirCookie::cookie() const
+ {
--    return blob_;
++    return cookie_;
+ }
 === modified file 'src/client/mir_cookie.h'
 --- src/client/mir_cookie.h	2016-01-22 20:16:50 +0000
 +++ src/client/mir_cookie.h	2016-09-18 20:00:37 +0000
@@ -20,21 +20,23 @@
  #ifndef MIR_CLIENT_MIR_COOKIE_H_
  #define MIR_CLIENT_MIR_COOKIE_H_
--#include "mir/cookie/blob.h"
++#include <cstdint>
++#include <cstdlib>
++#include <vector>
  class MirCookie
+ {
  public:
      explicit MirCookie(void const* buffer, size_t size);
--    explicit MirCookie(mir::cookie::Blob const& blob);
++    explicit MirCookie(std::vector<uint8_t> const& cookie);
      void copy_to(void* buffer, size_t size) const;
      size_t size() const;
--    mir::cookie::Blob blob() const;
++    std::vector<uint8_t> cookie() const;
  private:
--    mir::cookie::Blob blob_;
++    std::vector<uint8_t> cookie_;
  };
  #endif // MIR_CLIENT_MIR_COOKIE_H_
 === modified file 'src/client/mir_surface.cpp'
 --- src/client/mir_surface.cpp	2016-08-31 10:46:40 +0000
 +++ src/client/mir_surface.cpp	2016-09-18 20:00:37 +0000
@@ -496,7 +496,7 @@
      auto const event_cookie = raise_request.mutable_cookie();
--    event_cookie->set_cookie(cookie->blob().data(), cookie->size());
++    event_cookie->set_cookie(cookie->cookie().data(), cookie->size());
      server->raise_surface(
          &raise_request,
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2016-09-16 15:18:36 +0000
 +++ src/client/symbols.map	2016-09-18 20:00:37 +0000
@@ -429,6 +429,7 @@
      mir_output_get_gamma;
      mir_output_set_gamma;
      mir_connection_cancel_base_display_configuration_preview;
++    mir_input_device_state_event_device_pressed_keys_for_index;
      mir_surface_placement_get_relative_position;
      mir_display_output_type_name;
      mir_output_type_name;
 === modified file 'src/common/CMakeLists.txt'
 --- src/common/CMakeLists.txt	2016-09-16 15:18:36 +0000
 +++ src/common/CMakeLists.txt	2016-09-18 20:00:37 +0000
@@ -1,6 +1,5 @@
  add_definitions(-DMIR_LOG_COMPONENT_FALLBACK="mircommon")
--set(MIR_GENERATED_INCLUDE_DIRECTORIES)
  set(MIR_COMMON_SOURCES)
  set(MIR_COMMON_REFERENCES)
@@ -45,9 +44,12 @@
+ )
  target_link_libraries(mircommon
++  mircapnproto
    ${MIR_COMMON_REFERENCES}
+ )
++add_dependencies(mircommon mircapnproto)
++
  set_target_properties(mircommon
    PROPERTIES
 === modified file 'src/common/events/CMakeLists.txt'
 --- src/common/events/CMakeLists.txt	2016-09-16 15:18:36 +0000
 +++ src/common/events/CMakeLists.txt	2016-09-18 20:00:37 +0000
@@ -36,7 +36,10 @@
    ${EVENT_SOURCES}
+ )
++add_dependencies(mirevents mircapnproto)
++
  include_directories(
      ${PROJECT_SOURCE_DIR}/include/client
      ${PROJECT_SOURCE_DIR}/src/include/cookie
++    ${MIR_GENERATED_INCLUDE_DIRECTORIES}
+ )
 === modified file 'src/common/events/close_surface_event.cpp'
 --- src/common/events/close_surface_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/close_surface_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,17 +18,17 @@
  #include "mir/events/close_surface_event.h"
--MirCloseSurfaceEvent::MirCloseSurfaceEvent() :
--    MirEvent(mir_event_type_close_surface)
++MirCloseSurfaceEvent::MirCloseSurfaceEvent()
+ {
++    event.initCloseSurface();
+ }
  int MirCloseSurfaceEvent::surface_id() const
+ {
--    return surface_id_;
++    return event.asReader().getCloseSurface().getSurfaceId();
+ }
  void MirCloseSurfaceEvent::set_surface_id(int id)
+ {
--    surface_id_ = id;
++    event.getCloseSurface().setSurfaceId(id);
+ }
 === modified file 'src/common/events/event.cpp'
 --- src/common/events/event.cpp	2016-09-16 15:18:36 +0000
 +++ src/common/events/event.cpp	2016-09-18 20:00:37 +0000
@@ -18,8 +18,8 @@
  #include <boost/throw_exception.hpp>
++#include "mir/log.h"
  #include "mir/events/event.h"
--
  #include "mir/events/close_surface_event.h"
  #include "mir/events/input_configuration_event.h"
  #include "mir/events/input_event.h"
@@ -34,127 +34,91 @@
  #include "mir/events/input_device_state_event.h"
  #include "mir/events/surface_placement_event.h"
--MirEvent::MirEvent(MirEventType type) :
--    type_(type)
--{
--}
--
--MirEvent* MirEvent::clone() const
--{
--    switch (type_)
--    {
--    case mir_event_type_key:
--        return mir::event::deep_copy<MirKeyboardEvent>(this);
--    case mir_event_type_motion:
--        return mir::event::deep_copy<MirMotionEvent>(this);
--    case mir_event_type_surface:
--        return mir::event::deep_copy<MirSurfaceEvent>(this);
--    case mir_event_type_resize:
--        return mir::event::deep_copy<MirResizeEvent>(this);
--    case mir_event_type_prompt_session_state_change:
--        return mir::event::deep_copy<MirPromptSessionEvent>(this);
--    case mir_event_type_orientation:
--        return mir::event::deep_copy<MirOrientationEvent>(this);
--    case mir_event_type_close_surface:
--        return mir::event::deep_copy<MirCloseSurfaceEvent>(this);
--    case mir_event_type_input_configuration:
--        return mir::event::deep_copy<MirInputConfigurationEvent>(this);
--    case mir_event_type_surface_output:
--        return mir::event::deep_copy<MirSurfaceOutputEvent>(this);
--    case mir_event_type_keymap:
--        return to_keymap()->clone();
--    case mir_event_type_input_device_state:
--        return to_input_device_state()->clone();
--    case mir_event_type_surface_placement:
--        return mir::event::deep_copy<MirSurfacePlacementEvent>(this);
--    case mir_event_type_input:
--        break;
--    }
--
--    BOOST_THROW_EXCEPTION(std::runtime_error("Failed to clone event"));
--}
--
++#include <capnp/serialize.h>
++
++#include <unordered_map>
++
++namespace ml = mir::logging;
++
++namespace
++{
++std::unordered_map<MirEvent const*, std::shared_ptr<void>> event_lifetime_storage;
++}
++
++void* mir::event::store_data_for_lifetime_of_event(MirEvent const* ev, std::shared_ptr<void> const& data)
++{
++    event_lifetime_storage[ev] = data;
++    return data.get();
++}
++
++MirEvent::MirEvent(MirEvent const& e)
++{
++    auto reader = e.event.asReader();
++    message.setRoot(reader);
++    event = message.getRoot<mir::capnp::Event>();
++}
++
++MirEvent& MirEvent::operator=(MirEvent const& e)
++{
++    auto reader = e.event.asReader();
++    message.setRoot(reader);
++    event = message.getRoot<mir::capnp::Event>();
++    return *this;
++}
++
++// TODO Look at replacing the surface event serializer with a capnproto layer
  mir::EventUPtr MirEvent::deserialize(std::string const& bytes)
+ {
--    auto minimal_event_size = sizeof(MirEventType);
--    auto const stream_size = bytes.size();
--    if (stream_size < minimal_event_size)
--        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
--
--    MirEventType type;
--    mir::event::consume(bytes.data(), type);
--
--    switch (type)
--    {
--    case mir_event_type_key:
--        return mir::event::deserialize_from<MirKeyboardEvent>(bytes);
--    case mir_event_type_motion:
--        return mir::event::deserialize_from<MirMotionEvent>(bytes);
--    case mir_event_type_surface:
--        return mir::event::deserialize_from<MirSurfaceEvent>(bytes);
--    case mir_event_type_resize:
--        return mir::event::deserialize_from<MirResizeEvent>(bytes);
--    case mir_event_type_prompt_session_state_change:
--        return mir::event::deserialize_from<MirPromptSessionEvent>(bytes);
--    case mir_event_type_orientation:
--        return mir::event::deserialize_from<MirOrientationEvent>(bytes);
--    case mir_event_type_close_surface:
--        return mir::event::deserialize_from<MirCloseSurfaceEvent>(bytes);
--    case mir_event_type_input_configuration:
--        return mir::event::deserialize_from<MirInputConfigurationEvent>(bytes);
--    case mir_event_type_surface_output:
--        return mir::event::deserialize_from<MirSurfaceOutputEvent>(bytes);
--    case mir_event_type_keymap:
--        return MirKeymapEvent::deserialize(bytes);
--    case mir_event_type_input_device_state:
--        return MirInputDeviceStateEvent::deserialize(bytes);
--    case mir_event_type_surface_placement:
--        return mir::event::deserialize_from<MirSurfacePlacementEvent>(bytes);
--    case mir_event_type_input:
--        break;
--    }
--
--    BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
++    auto e = mir::EventUPtr(new MirEvent, [](MirEvent* ev) { event_lifetime_storage.erase(ev); delete ev; });
++    kj::ArrayPtr<::capnp::word const> words(reinterpret_cast<::capnp::word const*>(
++        bytes.data()), bytes.size() / sizeof(::capnp::word));
++
++    initMessageBuilderFromFlatArrayCopy(words, e->message);
++    e->event = e->message.getRoot<mir::capnp::Event>();
++
++    return e;
+ }
  std::string MirEvent::serialize(MirEvent const* event)
+ {
--    switch (event->type())
--    {
--    case mir_event_type_key:
--        return mir::event::serialize_from<MirKeyboardEvent>(event);
--    case mir_event_type_motion:
--        return mir::event::serialize_from<MirMotionEvent>(event);
--    case mir_event_type_surface:
--        return mir::event::serialize_from<MirSurfaceEvent>(event);
--    case mir_event_type_resize:
--        return mir::event::serialize_from<MirResizeEvent>(event);
--    case mir_event_type_prompt_session_state_change:
--        return mir::event::serialize_from<MirPromptSessionEvent>(event);
--    case mir_event_type_orientation:
--        return mir::event::serialize_from<MirOrientationEvent>(event);
--    case mir_event_type_close_surface:
--        return mir::event::serialize_from<MirCloseSurfaceEvent>(event);
--    case mir_event_type_input_configuration:
--        return mir::event::serialize_from<MirInputConfigurationEvent>(event);
--    case mir_event_type_surface_output:
--        return mir::event::serialize_from<MirSurfaceOutputEvent>(event);
--    case mir_event_type_keymap:
--        return MirKeymapEvent::serialize(event);
--    case mir_event_type_input_device_state:
--        return MirInputDeviceStateEvent::serialize(event);
--    case mir_event_type_surface_placement:
--        return mir::event::serialize_from<MirSurfacePlacementEvent>(event);
--    case mir_event_type_input:
--        break;
--    }
++	std::string output;
++	auto flat_event = ::capnp::messageToFlatArray(const_cast<MirEvent*>(event)->message);
--    BOOST_THROW_EXCEPTION(std::runtime_error("Failed to serialize event"));
++    return {reinterpret_cast<char*>(flat_event.asBytes().begin()), flat_event.asBytes().size()};
+ }
  MirEventType MirEvent::type() const
+ {
--    return type_;
++    switch (event.asReader().which())
++    {
++    case mir::capnp::Event::Which::KEY:
++        return mir_event_type_key;
++    case mir::capnp::Event::Which::MOTION_SET:
++        return mir_event_type_motion;
++    case mir::capnp::Event::Which::SURFACE:
++        return mir_event_type_surface;
++    case mir::capnp::Event::Which::RESIZE:
++        return mir_event_type_resize;
++    case mir::capnp::Event::Which::PROMPT_SESSION:
++        return mir_event_type_prompt_session_state_change;
++    case mir::capnp::Event::Which::ORIENTATION:
++        return mir_event_type_orientation;
++    case mir::capnp::Event::Which::CLOSE_SURFACE:
++        return mir_event_type_close_surface;
++    case mir::capnp::Event::Which::KEYMAP:
++        return mir_event_type_keymap;
++    case mir::capnp::Event::Which::INPUT_CONFIGURATION:
++        return mir_event_type_input_configuration;
++    case mir::capnp::Event::Which::SURFACE_OUTPUT:
++        return mir_event_type_surface_output;
++    case mir::capnp::Event::Which::INPUT_DEVICE:
++        return mir_event_type_input_device_state;
++    case mir::capnp::Event::Which::SURFACE_PLACEMENT:
++        return mir_event_type_surface_placement;
++    default:
++        mir::log_critical("unknown event type.");
++        abort();
++    }
+ }
  MirInputEvent* MirEvent::to_input()
 === modified file 'src/common/events/input_configuration_event.cpp'
 --- src/common/events/input_configuration_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/input_configuration_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,37 +18,37 @@
  #include "mir/events/input_configuration_event.h"
--MirInputConfigurationEvent::MirInputConfigurationEvent() :
--    MirEvent(mir_event_type_input_configuration)
++MirInputConfigurationEvent::MirInputConfigurationEvent()
+ {
++    event.initInputConfiguration();
+ }
  MirInputConfigurationAction MirInputConfigurationEvent::action() const
+ {
--    return action_;
++    return static_cast<MirInputConfigurationAction>(event.asReader().getInputConfiguration().getAction());
+ }
  void MirInputConfigurationEvent::set_action(MirInputConfigurationAction action)
+ {
--    action_ = action;
++    event.getInputConfiguration().setAction(static_cast<mir::capnp::InputConfigurationEvent::Action>(action));
+ }
  std::chrono::nanoseconds MirInputConfigurationEvent::when() const
+ {
--    return when_;
++    return std::chrono::nanoseconds{event.asReader().getInputConfiguration().getWhen().getCount()};
+ }
  void MirInputConfigurationEvent::set_when(std::chrono::nanoseconds const& when)
+ {
--    when_ = when;
++    event.getInputConfiguration().getWhen().setCount(when.count());
+ }
  MirInputDeviceId MirInputConfigurationEvent::id() const
+ {
--    return id_;
++    return event.asReader().getInputConfiguration().getId().getId();
+ }
  void MirInputConfigurationEvent::set_id(MirInputDeviceId id)
+ {
--    id_ = id;
++    event.getInputConfiguration().getId().setId(id);
+ }
 === modified file 'src/common/events/input_device_state_event.cpp'
 --- src/common/events/input_device_state_event.cpp	2016-05-26 20:59:38 +0000
 +++ src/common/events/input_device_state_event.cpp	2016-09-18 20:00:37 +0000
@@ -21,18 +21,18 @@
  #include <boost/throw_exception.hpp>
  MirInputDeviceStateEvent::MirInputDeviceStateEvent()
--    : MirEvent(mir_event_type_input_device_state)
+ {
++    event.initInputDevice();
+ }
  MirPointerButtons MirInputDeviceStateEvent::pointer_buttons() const
+ {
--    return pointer_buttons_;
++    return static_cast<MirPointerButtons>(event.asReader().getInputDevice().getButtons());
+ }
  void MirInputDeviceStateEvent::set_pointer_buttons(MirPointerButtons new_pointer_buttons)
+ {
--    pointer_buttons_ = new_pointer_buttons;
++    event.getInputDevice().setButtons(new_pointer_buttons);
+ }
  float MirInputDeviceStateEvent::pointer_axis(MirPointerAxis axis) const
@@ -40,9 +40,9 @@
      switch(axis)
+     {
      case mir_pointer_axis_x:
--        return pointer_x;
++        return event.asReader().getInputDevice().getPointerX();
      case mir_pointer_axis_y:
--        return pointer_y;
++        return event.asReader().getInputDevice().getPointerY();
      default:
          return 0.0f;
+     }
@@ -53,10 +53,10 @@
      switch(axis)
+     {
      case mir_pointer_axis_x:
--        pointer_x = value;
++        event.getInputDevice().setPointerX(value);
          break;
      case mir_pointer_axis_y:
--        pointer_y = value;
++        event.getInputDevice().setPointerY(value);
          break;
      default:
          break;
@@ -65,159 +65,74 @@
  std::chrono::nanoseconds MirInputDeviceStateEvent::when() const
+ {
--    return when_;
++    return std::chrono::nanoseconds{event.asReader().getInputDevice().getWhen().getCount()};
+ }
  void MirInputDeviceStateEvent::set_when(std::chrono::nanoseconds const& when)
+ {
--    when_ = when;
++    event.getInputDevice().getWhen().setCount(when.count());
+ }
  MirInputEventModifiers MirInputDeviceStateEvent::modifiers() const
+ {
--    return modifiers_;
++    return static_cast<MirInputEventModifiers>(event.asReader().getInputDevice().getModifiers());
+ }
  void MirInputDeviceStateEvent::set_modifiers(MirInputEventModifiers modifiers)
+ {
--    modifiers_ = modifiers;
++    event.getInputDevice().setModifiers(modifiers);
+ }
--void MirInputDeviceStateEvent::add_device(MirInputDeviceId id, std::vector<uint32_t> && pressed_keys, MirPointerButtons pointer_buttons)
++void MirInputDeviceStateEvent::set_device_states(std::vector<mir::events::InputDeviceState> const& device_states)
+ {
--    devices.emplace_back(id, std::move(pressed_keys), pointer_buttons);
++    event.getInputDevice().initDevices(device_states.size());
++
++    for (size_t i = 0; i < device_states.size(); i++)
++    {
++        auto const& state = device_states[i];
++        event.getInputDevice().getDevices()[i].getDeviceId().setId(state.id);
++        event.getInputDevice().getDevices()[i].setButtons(state.buttons);
++        event.getInputDevice().getDevices()[i].initPressedKeys(state.pressed_keys.size());
++        for (size_t j = 0; j < state.pressed_keys.size(); j++)
++        {
++            event.getInputDevice().getDevices()[i].getPressedKeys().set(j, state.pressed_keys[j]);
++        }
++    }
+ }
  uint32_t MirInputDeviceStateEvent::device_count() const
+ {
--    return devices.size();
++    return event.asReader().getInputDevice().getDevices().size();
+ }
  MirInputDeviceId MirInputDeviceStateEvent::device_id(size_t index) const
+ {
--    return devices[index].id;
--}
--
--uint32_t const* MirInputDeviceStateEvent::device_pressed_keys(size_t index) const
--{
--    return devices[index].pressed_keys.data();
++    return event.asReader().getInputDevice().getDevices()[index].getDeviceId().getId();
++}
++
++std::vector<uint32_t> MirInputDeviceStateEvent::device_pressed_keys(size_t index)
++{
++    auto pressed_keys = event.asReader().getInputDevice().getDevices()[index].getPressedKeys();
++    std::vector<uint32_t> pressed_keys_vector;
++    for (auto const& pk : pressed_keys)
++    {
++        pressed_keys_vector.push_back(pk);
++    }
++
++    return pressed_keys_vector;
++}
++
++uint32_t MirInputDeviceStateEvent::device_pressed_keys_for_index(size_t index, size_t pressed_index) const
++{
++    return event.asReader().getInputDevice().getDevices()[index].getPressedKeys()[pressed_index];
+ }
  uint32_t MirInputDeviceStateEvent::device_pressed_keys_count(size_t index) const
+ {
--    return devices[index].pressed_keys.size();
++    return event.asReader().getInputDevice().getDevices()[index].getPressedKeys().size();
+ }
  MirPointerButtons MirInputDeviceStateEvent::device_pointer_buttons(size_t index) const
+ {
--    return devices[index].pointer_buttons;
--}
--
--namespace
--{
--void delete_input_device_state_event(MirEvent* to)
--{
--    delete to->to_input_device_state();
--}
--template<typename Data>
--void encode(std::string& encoded, Data const& data)
--{
--    encoded.append(reinterpret_cast<char const*>(&data), sizeof data);
--}
--}
--
--mir::EventUPtr MirInputDeviceStateEvent::deserialize(std::string const& bytes)
--{
--    auto const stream_size = bytes.size();
--
--    MirEventType type;
--    std::chrono::nanoseconds when;
--    MirInputEventModifiers modifiers;
--    MirPointerButtons pointer_buttons;
--    float pointer_x;
--    float pointer_y;
--    uint32_t count;
--
--    auto minimal_event_size = sizeof type + sizeof when + sizeof modifiers + sizeof pointer_buttons + sizeof pointer_x +
--                              sizeof pointer_y + sizeof count;
--
--    if (stream_size < minimal_event_size)
--        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
--
--    char const* pos = mir::event::consume(bytes.data(), type);
--    pos = mir::event::consume(pos, when);
--    pos = mir::event::consume(pos, modifiers);
--    pos = mir::event::consume(pos, pointer_buttons);
--    pos = mir::event::consume(pos, pointer_x);
--    pos = mir::event::consume(pos, pointer_y);
--    pos = mir::event::consume(pos, count);
--
--    auto new_event = new MirInputDeviceStateEvent;
--    new_event->set_when(when);
--    new_event->set_modifiers(modifiers);
--    new_event->set_pointer_buttons(pointer_buttons);
--    new_event->set_pointer_axis(mir_pointer_axis_x, pointer_x);
--    new_event->set_pointer_axis(mir_pointer_axis_y, pointer_y);
--
--    for (size_t i = 0; i != count; ++i)
--    {
--        uint32_t pressed_count = 0;
--        MirInputDeviceId id;
--        pos = mir::event::consume(pos, id);
--        pos = mir::event::consume(pos, pointer_buttons);
--        pos = mir::event::consume(pos, pressed_count);
--
--        std::vector<uint32_t> pressed_keys(pressed_count);
--
--        for (size_t j = 0;j != pressed_count; ++j)
--            pos = mir::event::consume(pos, pressed_keys[j]);
--
--        new_event->add_device(id, std::move(pressed_keys), pointer_buttons);
--    }
--
--    return mir::EventUPtr(new_event, delete_input_device_state_event);
--}
--
--std::string MirInputDeviceStateEvent::serialize(MirEvent const* event)
--{
--    std::string encoded;
--    auto input_state = event->to_input_device_state();
--    encoded.reserve(sizeof event->type() +
--                    sizeof input_state->when() +
--                    sizeof input_state->modifiers() +
--                    sizeof input_state->pointer_buttons() +
--                    sizeof input_state->pointer_axis(mir_pointer_axis_x) +
--                    sizeof input_state->pointer_axis(mir_pointer_axis_y) +
--                    sizeof input_state->device_count() +
--                    input_state->device_count() *
--                    (
--                        sizeof input_state->device_id(0) +
--                        sizeof input_state->device_pointer_buttons(0) +
--                        sizeof input_state->device_pressed_keys_count(0)
--                    )
--                    );
--    encode(encoded, event->type());
--    encode(encoded, input_state->when());
--    encode(encoded, input_state->modifiers());
--    encode(encoded, input_state->pointer_buttons());
--    encode(encoded, input_state->pointer_axis(mir_pointer_axis_x));
--    encode(encoded, input_state->pointer_axis(mir_pointer_axis_y));
--    encode(encoded, input_state->device_count());
--    for (auto const& dev : input_state->devices)
--    {
--        encode(encoded, dev.id);
--        encode(encoded, dev.pointer_buttons);
--        encode(encoded, uint32_t(dev.pressed_keys.size()));
--        for (auto const& key : dev.pressed_keys)
--            encode(encoded, key);
--    }
--
--    return encoded;
--
--}
--
--MirEvent* MirInputDeviceStateEvent::clone() const
--{
--    auto new_ev = new MirInputDeviceStateEvent(*this);
--    return new_ev;
++    return event.asReader().getInputDevice().getDevices()[index].getButtons();
+ }
 === modified file 'src/common/events/input_event.cpp'
 --- src/common/events/input_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/input_event.cpp	2016-09-18 20:00:37 +0000
@@ -21,11 +21,6 @@
  #include "mir/events/keyboard_event.h"
  #include "mir/events/motion_event.h"
--MirInputEvent::MirInputEvent(MirEventType type) :
--    MirEvent(type)
--{
--}
--
  MirKeyboardEvent* MirInputEvent::to_keyboard()
+ {
      return static_cast<MirKeyboardEvent*>(this);
 === modified file 'src/common/events/keyboard_event.cpp'
 --- src/common/events/keyboard_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/keyboard_event.cpp	2016-09-18 20:00:37 +0000
@@ -19,87 +19,92 @@
  #include "mir/events/input_event.h"
  #include "mir/events/keyboard_event.h"
--MirKeyboardEvent::MirKeyboardEvent() :
--    MirInputEvent(mir_event_type_key)
++MirKeyboardEvent::MirKeyboardEvent()
+ {
++    event.initKey();
+ }
  int32_t MirKeyboardEvent::device_id() const
+ {
--    return device_id_;
++    return event.asReader().getKey().getDeviceId().getId();
+ }
  void MirKeyboardEvent::set_device_id(int32_t id)
+ {
--    device_id_ = id;
++    event.getKey().getDeviceId().setId(id);
+ }
  int32_t MirKeyboardEvent::source_id() const
+ {
--    return source_id_;
++    return event.asReader().getKey().getSourceId();
+ }
  void MirKeyboardEvent::set_source_id(int32_t id)
+ {
--    source_id_ = id;
++    event.getKey().setSourceId(id);
+ }
  MirKeyboardAction MirKeyboardEvent::action() const
+ {
--    return action_;
++    return static_cast<MirKeyboardAction>(event.asReader().getKey().getAction());
+ }
  void MirKeyboardEvent::set_action(MirKeyboardAction action)
+ {
--    action_ = action;
++    event.getKey().setAction(static_cast<mir::capnp::KeyboardEvent::Action>(action));
+ }
  MirInputEventModifiers MirKeyboardEvent::modifiers() const
+ {
--    return modifiers_;
++    return event.asReader().getKey().getModifiers();
+ }
  void MirKeyboardEvent::set_modifiers(MirInputEventModifiers modifiers)
+ {
--    modifiers_ = modifiers;
++    event.getKey().setModifiers(modifiers);
+ }
  int32_t MirKeyboardEvent::key_code() const
+ {
--    return key_code_;
++    return event.asReader().getKey().getKeyCode();
+ }
  void MirKeyboardEvent::set_key_code(int32_t key_code)
+ {
--    key_code_ = key_code;
++    event.getKey().setKeyCode(key_code);
+ }
  int32_t MirKeyboardEvent::scan_code() const
+ {
--    return scan_code_;
++    return event.asReader().getKey().getScanCode();
+ }
  void MirKeyboardEvent::set_scan_code(int32_t scan_code)
+ {
--    scan_code_ = scan_code;
++    event.getKey().setScanCode(scan_code);
+ }
  std::chrono::nanoseconds MirKeyboardEvent::event_time() const
+ {
--    return event_time_;
++    return std::chrono::nanoseconds{event.asReader().getKey().getEventTime().getCount()};
+ }
  void MirKeyboardEvent::set_event_time(std::chrono::nanoseconds const& event_time)
+ {
--    event_time_ = event_time;
--}
--
--mir::cookie::Blob MirKeyboardEvent::cookie() const
--{
--    return cookie_;
--}
--
--void MirKeyboardEvent::set_cookie(mir::cookie::Blob const& cookie)
--{
--    cookie_ = cookie;
++    event.getKey().getEventTime().setCount(event_time.count());
++}
++
++std::vector<uint8_t> MirKeyboardEvent::cookie() const
++{
++    auto cookie = event.asReader().getKey().getCookie();
++    std::vector<uint8_t> vec_cookie(cookie.size());
++    std::copy(std::begin(cookie), std::end(cookie), std::begin(vec_cookie));
++
++    return vec_cookie;
++}
++
++void MirKeyboardEvent::set_cookie(std::vector<uint8_t> const& cookie)
++{
++    ::capnp::Data::Reader cookie_data(cookie.data(), cookie.size());
++    event.getKey().setCookie(cookie_data);
+ }
 === modified file 'src/common/events/keymap_event.cpp'
 --- src/common/events/keymap_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/keymap_event.cpp	2016-09-18 20:00:37 +0000
@@ -20,145 +20,43 @@
  #include "mir/events/keymap_event.h"
--namespace
--{
--void delete_keymap_event(MirEvent* e)
--{
--    if (e && e->to_keymap()->buffer())
--    {
--        e->to_keymap()->free_buffer();
--    }
--
--    delete e;
--}
--
--template<typename Data>
--void encode(std::string& encoded, Data const& data)
--{
--    encoded.append(reinterpret_cast<char const*>(&data), sizeof data);
--}
--}
--
--MirKeymapEvent::MirKeymapEvent() :
--    MirEvent(mir_event_type_keymap)
--{
--}
--
--MirEvent* MirKeymapEvent::clone() const
--{
--    auto new_ev = mir::event::deep_copy<MirKeymapEvent>(this);
--    auto keymap = new_ev->to_keymap();
--
--    // malloc to match xkbcommons allocation behavior
--    auto buffer = static_cast<char*>(malloc(keymap->size()));
--    std::memcpy(buffer, keymap->buffer(), keymap->size());
--    keymap->set_buffer(buffer);
--
--    return new_ev;
--}
--
--// Edge case where we have handle the char* buffer manually!
--mir::EventUPtr MirKeymapEvent::deserialize(std::string const& bytes)
--{
--    MirInputDeviceId device_id;
--    int surface_id;
--    size_t size;
--
--    auto minimal_event_size = sizeof(MirEventType);
--    auto const stream_size = bytes.size();
--    if (stream_size < minimal_event_size)
--        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
--
--    MirEventType type;
--    char const* pos = mir::event::consume(bytes.data(), type);
--
--    minimal_event_size += sizeof(surface_id) + sizeof(device_id) + sizeof(size);
--
--    if (stream_size < minimal_event_size)
--        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
--
--    pos = mir::event::consume(pos, surface_id);
--    pos = mir::event::consume(pos, device_id);
--    pos = mir::event::consume(pos, size);
--
--    minimal_event_size += size;
--
--    if (stream_size < minimal_event_size)
--        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
--
--    auto buffer = static_cast<char*>(std::malloc(size));
--    std::memcpy(buffer, pos, size);
--
--    auto new_event = new MirKeymapEvent;
--    new_event->set_surface_id(surface_id);
--    new_event->set_device_id(device_id);
--    new_event->set_size(size);
--    new_event->set_buffer(buffer);
--
--    return mir::EventUPtr(new_event, delete_keymap_event);
--}
--
--
--// Edge case where we have handle the char* buffer manually!
--std::string MirKeymapEvent::serialize(MirEvent const* event)
--{
--    std::string encoded;
--    auto keymap = event->to_keymap();
--    encoded.reserve(sizeof event->type() +
--                    sizeof keymap->surface_id() +
--                    sizeof keymap->device_id() +
--                    sizeof keymap->size() +
--                    keymap->size());
--    encode(encoded, event->type());
--    encode(encoded, keymap->surface_id());
--    encode(encoded, keymap->device_id());
--    encode(encoded, keymap->size());
--    encoded.append(keymap->buffer(), keymap->size());
--
--    return encoded;
++MirKeymapEvent::MirKeymapEvent()
++{
++    event.initKeymap();
+ }
  int MirKeymapEvent::surface_id() const
+ {
--    return surface_id_;
++    return event.asReader().getKeymap().getSurfaceId();
+ }
  void MirKeymapEvent::set_surface_id(int id)
+ {
--    surface_id_ = id;
++    event.getKeymap().setSurfaceId(id);
+ }
  MirInputDeviceId MirKeymapEvent::device_id() const
+ {
--    return device_id_;
++    return event.asReader().getKeymap().getDeviceId().getId();
+ }
  void MirKeymapEvent::set_device_id(MirInputDeviceId id)
+ {
--    device_id_ = id;
++    event.getKeymap().getDeviceId().setId(id);
+ }
  char const* MirKeymapEvent::buffer() const
+ {
--    return buffer_;
++    return event.asReader().getKeymap().getBuffer().cStr();
+ }
  void MirKeymapEvent::set_buffer(char const* buffer)
+ {
--    buffer_ = buffer;
--}
--
--void MirKeymapEvent::free_buffer()
--{
--    std::free(const_cast<char*>(buffer_));
++    ::capnp::Text::Reader capnp_text(buffer, strlen(buffer));
++    event.getKeymap().setBuffer(capnp_text);
+ }
  size_t MirKeymapEvent::size() const
+ {
--    return size_;
--}
--
--void MirKeymapEvent::set_size(size_t size)
--{
--    size_ = size;
++    return event.asReader().getKeymap().getBuffer().size();
+ }
 === modified file 'src/common/events/motion_event.cpp'
 --- src/common/events/motion_event.cpp	2016-03-30 05:27:27 +0000
 +++ src/common/events/motion_event.cpp	2016-09-18 20:00:37 +0000
@@ -20,303 +20,288 @@
  #include "mir/events/motion_event.h"
--MirMotionEvent::MirMotionEvent() :
--    MirInputEvent(mir_event_type_motion)
++MirMotionEvent::MirMotionEvent()
+ {
++    event.initMotionSet();
++    event.getMotionSet().initMotions(mir::capnp::MotionSetEvent::MAX_COUNT);
+ }
  int32_t MirMotionEvent::device_id() const
+ {
--    return device_id_;
++    return event.asReader().getMotionSet().getDeviceId().getId();
+ }
  void MirMotionEvent::set_device_id(int32_t id)
+ {
--    device_id_ = id;
++    event.getMotionSet().getDeviceId().setId(id);
+ }
  int32_t MirMotionEvent::source_id() const
+ {
--    return source_id_;
++    return event.asReader().getMotionSet().getSourceId();
+ }
  void MirMotionEvent::set_source_id(int32_t id)
+ {
--    source_id_ = id;
++    event.getMotionSet().setSourceId(id);
+ }
  MirInputEventModifiers MirMotionEvent::modifiers() const
+ {
--    return modifiers_;
++    return event.asReader().getMotionSet().getModifiers();
+ }
  void MirMotionEvent::set_modifiers(MirInputEventModifiers modifiers)
+ {
--    modifiers_ = modifiers;
++    event.getMotionSet().setModifiers(modifiers);
+ }
  MirPointerButtons MirMotionEvent::buttons() const
+ {
--    return buttons_;
++    return event.asReader().getMotionSet().getButtons();
+ }
  void MirMotionEvent::set_buttons(MirPointerButtons buttons)
+ {
--    buttons_ = buttons;
++    event.getMotionSet().setButtons(buttons);
+ }
  std::chrono::nanoseconds MirMotionEvent::event_time() const
+ {
--    return event_time_;
++    return std::chrono::nanoseconds{event.asReader().getMotionSet().getEventTime().getCount()};
+ }
  void MirMotionEvent::set_event_time(std::chrono::nanoseconds const& event_time)
+ {
--    event_time_ = event_time;
--}
--
--mir::cookie::Blob MirMotionEvent::cookie() const
--{
--    return cookie_;
--}
--
--void MirMotionEvent::set_cookie(mir::cookie::Blob const& blob)
--{
--    cookie_ = blob;
++    event.getMotionSet().getEventTime().setCount(event_time.count());
++}
++
++std::vector<uint8_t> MirMotionEvent::cookie() const
++{
++    auto cookie = event.asReader().getMotionSet().getCookie();
++    std::vector<uint8_t> vec_cookie(cookie.size());
++    std::copy(std::begin(cookie), std::end(cookie), std::begin(vec_cookie));
++
++    return vec_cookie;
++}
++
++void MirMotionEvent::set_cookie(std::vector<uint8_t> const& cookie)
++{
++    ::capnp::Data::Reader cookie_data(cookie.data(), cookie.size());
++    event.getMotionSet().setCookie(cookie_data);
+ }
  size_t MirMotionEvent::pointer_count() const
+ {
--    return pointer_count_;
++    return event.asReader().getMotionSet().getCount();
+ }
  void MirMotionEvent::set_pointer_count(size_t count)
+ {
--    pointer_count_ = count;
++    return event.getMotionSet().setCount(count);
++}
++
++void MirMotionEvent::throw_if_out_of_bounds(size_t index) const
++{
++    if (index > event.asReader().getMotionSet().getCount())
++         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
+ }
  int MirMotionEvent::id(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].id;
++    return event.asReader().getMotionSet().getMotions()[index].getId();
+ }
  void MirMotionEvent::set_id(size_t index, int id)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].id = id;
++    event.getMotionSet().getMotions()[index].setId(id);
+ }
  float MirMotionEvent::x(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].x;
++    return event.asReader().getMotionSet().getMotions()[index].getX();
+ }
  void MirMotionEvent::set_x(size_t index, float x)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].x = x;
++    event.getMotionSet().getMotions()[index].setX(x);
+ }
  float MirMotionEvent::y(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].y;
++    return event.asReader().getMotionSet().getMotions()[index].getY();
+ }
  void MirMotionEvent::set_y(size_t index, float y)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].y = y;
++    event.getMotionSet().getMotions()[index].setY(y);
+ }
  float MirMotionEvent::dx(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].dx;
++    return event.asReader().getMotionSet().getMotions()[index].getDx();
+ }
  void MirMotionEvent::set_dx(size_t index, float dx)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].dx = dx;
++    event.getMotionSet().getMotions()[index].setDx(dx);
+ }
  float MirMotionEvent::dy(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].dy;
++    return event.asReader().getMotionSet().getMotions()[index].getDy();
+ }
  void MirMotionEvent::set_dy(size_t index, float dy)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].dy = dy;
++    event.getMotionSet().getMotions()[index].setDy(dy);
+ }
  float MirMotionEvent::touch_major(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].touch_major;
++    return event.asReader().getMotionSet().getMotions()[index].getTouchMajor();
+ }
  void MirMotionEvent::set_touch_major(size_t index, float major)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].touch_major = major;
++    event.getMotionSet().getMotions()[index].setTouchMajor(major);
+ }
  float MirMotionEvent::touch_minor(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].touch_minor;
++    return event.asReader().getMotionSet().getMotions()[index].getTouchMinor();
+ }
  void MirMotionEvent::set_touch_minor(size_t index, float minor)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].touch_minor = minor;
++    event.getMotionSet().getMotions()[index].setTouchMinor(minor);
+ }
  float MirMotionEvent::size(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].size;
++    return event.asReader().getMotionSet().getMotions()[index].getSize();
+ }
  void MirMotionEvent::set_size(size_t index, float size)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].size = size;
++    event.getMotionSet().getMotions()[index].setSize(size);
+ }
  float MirMotionEvent::pressure(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].pressure;
++    return event.asReader().getMotionSet().getMotions()[index].getPressure();
+ }
  void MirMotionEvent::set_pressure(size_t index, float pressure)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].pressure = pressure;
++    event.getMotionSet().getMotions()[index].setPressure(pressure);
+ }
  float MirMotionEvent::orientation(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].orientation;
++    return event.asReader().getMotionSet().getMotions()[index].getOrientation();
+ }
  void MirMotionEvent::set_orientation(size_t index, float orientation)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].orientation = orientation;
++    event.getMotionSet().getMotions()[index].setOrientation(orientation);
+ }
  float MirMotionEvent::vscroll(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].vscroll;
++    return event.asReader().getMotionSet().getMotions()[index].getVscroll();
+ }
  void MirMotionEvent::set_vscroll(size_t index, float vscroll)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].vscroll = vscroll;
++    event.getMotionSet().getMotions()[index].setVscroll(vscroll);
+ }
  float MirMotionEvent::hscroll(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].hscroll;
++    return event.asReader().getMotionSet().getMotions()[index].getHscroll();
+ }
  void MirMotionEvent::set_hscroll(size_t index, float hscroll)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].hscroll = hscroll;
++    event.getMotionSet().getMotions()[index].setHscroll(hscroll);
+ }
  MirTouchTooltype MirMotionEvent::tool_type(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].tool_type;
++    return static_cast<MirTouchTooltype>(event.asReader().getMotionSet().getMotions()[index].getToolType());
+ }
  void MirMotionEvent::set_tool_type(size_t index, MirTouchTooltype tool_type)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].tool_type = tool_type;
++    auto capnp_tool_type = static_cast<mir::capnp::MotionSetEvent::Motion::ToolType>(tool_type);
++    event.getMotionSet().getMotions()[index].setToolType(capnp_tool_type);
+ }
  int MirMotionEvent::action(size_t index) const
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    return pointer_coordinates_[index].action;
++    return event.asReader().getMotionSet().getMotions()[index].getAction();
+ }
  void MirMotionEvent::set_action(size_t index, int action)
+ {
--    if (index > pointer_count_)
--         BOOST_THROW_EXCEPTION(std::out_of_range("Out of bounds index in pointer coordinates"));
++    throw_if_out_of_bounds(index);
--    pointer_coordinates_[index].action = action;
++    event.getMotionSet().getMotions()[index].setAction(action);
+ }
  MirTouchEvent* MirMotionEvent::to_touch()
 === modified file 'src/common/events/orientation_event.cpp'
 --- src/common/events/orientation_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/orientation_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,27 +18,27 @@
  #include "mir/events/orientation_event.h"
--MirOrientationEvent::MirOrientationEvent() :
--    MirEvent(mir_event_type_orientation)
++MirOrientationEvent::MirOrientationEvent()
+ {
++    event.initOrientation();
+ }
  int MirOrientationEvent::surface_id() const
+ {
--    return surface_id_;
++    return event.asReader().getOrientation().getSurfaceId();
+ }
  void MirOrientationEvent::set_surface_id(int id)
+ {
--    surface_id_ = id;
++    event.getOrientation().setSurfaceId(id);
+ }
  MirOrientation MirOrientationEvent::direction() const
+ {
--    return direction_;
++    return static_cast<MirOrientation>(event.asReader().getOrientation().getDirection());
+ }
  void MirOrientationEvent::set_direction(MirOrientation orientation)
+ {
--    direction_ = orientation;
++    event.getOrientation().setDirection(orientation);
+ }
 === modified file 'src/common/events/prompt_session_event.cpp'
 --- src/common/events/prompt_session_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/prompt_session_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,17 +18,17 @@
  #include "mir/events/prompt_session_event.h"
--MirPromptSessionEvent::MirPromptSessionEvent() :
--    MirEvent(mir_event_type_prompt_session_state_change)
++MirPromptSessionEvent::MirPromptSessionEvent()
+ {
++    event.initPromptSession();
+ }
  MirPromptSessionState MirPromptSessionEvent::new_state() const
+ {
--    return new_state_;
++    return static_cast<MirPromptSessionState>(event.asReader().getPromptSession().getNewState());
+ }
  void MirPromptSessionEvent::set_new_state(MirPromptSessionState state)
+ {
--    new_state_ = state;
++    event.getPromptSession().setNewState(static_cast<mir::capnp::PromptSessionEvent::State>(state));
+ }
 === modified file 'src/common/events/resize_event.cpp'
 --- src/common/events/resize_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/resize_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,37 +18,37 @@
  #include "mir/events/resize_event.h"
--MirResizeEvent::MirResizeEvent() :
--    MirEvent(mir_event_type_resize)
++MirResizeEvent::MirResizeEvent()
+ {
++    event.initResize();
+ }
  int MirResizeEvent::surface_id() const
+ {
--    return surface_id_;
++    return event.asReader().getResize().getSurfaceId();
+ }
  void MirResizeEvent::set_surface_id(int id)
+ {
--    surface_id_ = id;
++    event.getResize().setSurfaceId(id);
+ }
  int MirResizeEvent::width() const
+ {
--    return width_;
++    return event.asReader().getResize().getWidth();
+ }
  void MirResizeEvent::set_width(int width)
+ {
--    width_ = width;
++    event.getResize().setWidth(width);
+ }
  int MirResizeEvent::height() const
+ {
--    return height_;
++    return event.asReader().getResize().getHeight();
+ }
  void MirResizeEvent::set_height(int height)
+ {
--    height_ = height;
++    event.getResize().setHeight(height);
+ }
 === modified file 'src/common/events/surface_event.cpp'
 --- src/common/events/surface_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/surface_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,37 +18,37 @@
  #include "mir/events/surface_event.h"
--MirSurfaceEvent::MirSurfaceEvent() :
--    MirEvent(mir_event_type_surface)
++MirSurfaceEvent::MirSurfaceEvent()
+ {
++    event.initSurface();
+ }
  int MirSurfaceEvent::id() const
+ {
--    return id_;
++    return event.asReader().getSurface().getId();
+ }
  void MirSurfaceEvent::set_id(int id)
+ {
--    id_ = id;
++    event.getSurface().setId(id);
+ }
  MirSurfaceAttrib MirSurfaceEvent::attrib() const
+ {
--    return attrib_;
++    return static_cast<MirSurfaceAttrib>(event.asReader().getSurface().getAttrib());
+ }
  void MirSurfaceEvent::set_attrib(MirSurfaceAttrib attrib)
+ {
--    attrib_ = attrib;
++    event.getSurface().setAttrib(static_cast<mir::capnp::SurfaceEvent::Attrib>(attrib));
+ }
  int MirSurfaceEvent::value() const
+ {
--    return value_;
++    return event.asReader().getSurface().getValue();
+ }
  void MirSurfaceEvent::set_value(int value)
+ {
--    value_ = value;
++    event.getSurface().setValue(value);
+ }
 === modified file 'src/common/events/surface_output_event.cpp'
 --- src/common/events/surface_output_event.cpp	2016-03-29 03:41:45 +0000
 +++ src/common/events/surface_output_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,57 +18,57 @@
  #include "mir/events/surface_output_event.h"
--MirSurfaceOutputEvent::MirSurfaceOutputEvent() :
--    MirEvent(mir_event_type_surface_output)
++MirSurfaceOutputEvent::MirSurfaceOutputEvent()
+ {
++    event.initSurfaceOutput();
+ }
  int MirSurfaceOutputEvent::surface_id() const
+ {
--    return surface_id_;
++    return event.asReader().getSurfaceOutput().getSurfaceId();
+ }
  void MirSurfaceOutputEvent::set_surface_id(int id)
+ {
--    surface_id_ = id;
++    event.getSurfaceOutput().setSurfaceId(id);
+ }
  int MirSurfaceOutputEvent::dpi() const
+ {
--    return dpi_;
++    return event.asReader().getSurfaceOutput().getDpi();
+ }
  void MirSurfaceOutputEvent::set_dpi(int dpi)
+ {
--    dpi_ = dpi;
++    event.getSurfaceOutput().setDpi(dpi);
+ }
  float MirSurfaceOutputEvent::scale() const
+ {
--    return scale_;
++    return event.asReader().getSurfaceOutput().getScale();
+ }
  void MirSurfaceOutputEvent::set_scale(float scale)
+ {
--    scale_ = scale;
++    event.getSurfaceOutput().setScale(scale);
+ }
  MirFormFactor MirSurfaceOutputEvent::form_factor() const
+ {
--    return form_factor_;
++    return static_cast<MirFormFactor>(event.asReader().getSurfaceOutput().getFormFactor());
+ }
  void MirSurfaceOutputEvent::set_form_factor(MirFormFactor factor)
+ {
--    form_factor_ = factor;
++    event.getSurfaceOutput().setFormFactor(static_cast<mir::capnp::SurfaceOutputEvent::FormFactor>(factor));
+ }
  uint32_t MirSurfaceOutputEvent::output_id() const
+ {
--    return output_id_;
++    return event.asReader().getSurfaceOutput().getOutputId();
+ }
  void MirSurfaceOutputEvent::set_output_id(uint32_t id)
+ {
--    output_id_ = id;
++    event.getSurfaceOutput().setOutputId(id);
+ }
 === modified file 'src/common/events/surface_placement_event.cpp'
 --- src/common/events/surface_placement_event.cpp	2016-09-12 14:18:39 +0000
 +++ src/common/events/surface_placement_event.cpp	2016-09-18 20:00:37 +0000
@@ -18,29 +18,34 @@
  #include "mir/events/surface_placement_event.h"
--MirSurfacePlacementEvent::MirSurfacePlacementEvent() :
--    MirEvent(mir_event_type_surface_placement)
++MirSurfacePlacementEvent::MirSurfacePlacementEvent()
+ {
++    event.initSurfacePlacement();
+ }
  int MirSurfacePlacementEvent::id() const
+ {
--    return id_;
++    return event.asReader().getSurfacePlacement().getId();
+ }
  void MirSurfacePlacementEvent::set_id(int const id)
+ {
--    id_ = id;
++    event.getSurfacePlacement().setId(id);
+ }
  MirRectangle MirSurfacePlacementEvent::placement() const
+ {
--    return placement_;
++    auto rect = event.asReader().getSurfacePlacement().getRectangle();
++    return {rect.getLeft(), rect.getTop(), rect.getWidth(), rect.getHeight()};
+ }
  void MirSurfacePlacementEvent::set_placement(MirRectangle const& placement)
+ {
--    placement_ = placement;
++    auto rect = event.getSurfacePlacement().getRectangle();
++    rect.setLeft(placement.left);
++    rect.setTop(placement.top);
++    rect.setWidth(placement.width);
++    rect.setHeight(placement.height);
+ }
  MirSurfacePlacementEvent const* MirEvent::to_surface_placement() const
 === modified file 'src/common/symbols.map'
 --- src/common/symbols.map	2016-09-16 15:18:36 +0000
 +++ src/common/symbols.map	2016-09-18 20:00:37 +0000
@@ -360,9 +360,6 @@
         android::InputPublisher::publishEventBuffer*;
         MirEvent::to_input_device_state*;
         MirInputDeviceStateEvent::MirInputDeviceStateEvent*;
--       MirInputDeviceStateEvent::add_device*;
--       MirInputDeviceStateEvent::clone*;
--       MirInputDeviceStateEvent::deserialize*;
         MirInputDeviceStateEvent::device_count*;
         MirInputDeviceStateEvent::device_id*;
         MirInputDeviceStateEvent::device_pointer_buttons*;
@@ -371,7 +368,6 @@
         MirInputDeviceStateEvent::modifiers*;
         MirInputDeviceStateEvent::pointer_axis*;
         MirInputDeviceStateEvent::pointer_buttons*;
--       MirInputDeviceStateEvent::serialize*;
         MirInputDeviceStateEvent::set_modifiers*;
         MirInputDeviceStateEvent::set_pointer_axis*;
         MirInputDeviceStateEvent::set_pointer_buttons*;
@@ -390,6 +386,12 @@
  MIR_COMMON_0.25 {
    global:
      extern "C++" {
++      MirEvent::MirEvent*;
++      MirEvent::operator*;
++      MirInputEvent::operator*;
++      MirInputDeviceStateEvent::set_device_states*;
++      MirInputDeviceStateEvent::device_pressed_keys_for_index*;
++      mir::event::store_data_for_lifetime_of_event*;
        MirSurfacePlacementEvent::MirSurfacePlacementEvent*;
        MirSurfacePlacementEvent::id*;
        MirSurfacePlacementEvent::set_id*;
 === modified file 'src/include/common/mir/events/close_surface_event.h'
 --- src/include/common/mir/events/close_surface_event.h	2016-03-30 18:47:45 +0000
 +++ src/include/common/mir/events/close_surface_event.h	2016-09-18 20:00:37 +0000
@@ -27,9 +27,6 @@
      int surface_id() const;
      void set_surface_id(int id);
--
--private:
--    int surface_id_{-1};
  };
  #endif /* MIR_COMMON_CLOSE_SURFACE_EVENT_H_ */
 === modified file 'src/include/common/mir/events/event.h'
 --- src/include/common/mir/events/event.h	2016-09-16 15:18:36 +0000
 +++ src/include/common/mir/events/event.h	2016-09-18 20:00:37 +0000
@@ -21,14 +21,33 @@
  #include "mir_toolkit/event.h"
  #include "mir/events/event_builders.h"
++#include "mir_event.capnp.h"
++
++#include <capnp/message.h>
  #include <cstring>
  // Only MirPointerEvent and MirTouchEvent are typedefed in the public API
  typedef struct MirMotionEvent MirMotionEvent;
++namespace mir
++{
++namespace event
++{
++/* Evil hack to keep data around for the lifetime of an event.
++ * The reference will go down when the event it self goes out of scope.
++ * TODO: Remove this once we can remove this public function:
++ * uint32_t const* mir_input_device_state_event_device_pressed_keys
++ */
++void* store_data_for_lifetime_of_event(MirEvent const* ev, std::shared_ptr<void> const& data);
++}
++}
++
  struct MirEvent
+ {
++    MirEvent(MirEvent const& event);
++    MirEvent& operator=(MirEvent const& event);
++
      MirEventType type() const;
      MirInputEvent* to_input();
@@ -70,69 +89,9 @@
  protected:
      MirEvent() = default;
--    explicit MirEvent(MirEventType type);
--    MirEvent(MirEvent const& event) = default;
--    MirEvent& operator=(MirEvent const& event) = default;
--    MirEventType type_;
++    ::capnp::MallocMessageBuilder message;
++    mir::capnp::Event::Builder event{message.initRoot<mir::capnp::Event>()};
  };
--namespace mir
--{
--namespace event
--{
--template<typename Data>
--char const* consume(char const* pos, Data& data)
--{
--    std::memcpy(&data, pos, sizeof data);
--    return pos + sizeof data;
--}
--
--template<typename T>
--void assert_type_is_trivially_copyable()
--{
--#if __GNUC__ >= 5
--    static_assert(std::is_trivially_copyable<T>::value, "");
--#else
--    static_assert(__has_trivial_copy(T), "");
--#endif
--}
--
--// T needs to be trivially copyable
--// vivid wont allow a std::is_trivially_copyable
--template<typename T>
--mir::EventUPtr deserialize_from(std::string const& bytes)
--{
--    assert_type_is_trivially_copyable<T>();
--
--    T* t = new T;
--    memcpy(t, bytes.data(), bytes.size());
--
--    return mir::EventUPtr(t, [](MirEvent* e) { delete e; });
--}
--
--template<typename T>
--std::string serialize_from(MirEvent const* ev)
--{
--    assert_type_is_trivially_copyable<T>();
--
--    std::string encoded_bytes;
--    encoded_bytes.append(reinterpret_cast<char const*>(ev), sizeof(T));
--
--    return encoded_bytes;
--}
--
--template<typename T>
--MirEvent* deep_copy(MirEvent const* ev)
--{
--    assert_type_is_trivially_copyable<T>();
--
--    T* t = new T;
--    memcpy(t, ev, sizeof(T));
--
--    return t;
--}
--}
--}
--
  #endif /* MIR_COMMON_EVENT_H_ */
 === modified file 'src/include/common/mir/events/input_configuration_event.h'
 --- src/include/common/mir/events/input_configuration_event.h	2016-03-30 19:01:10 +0000
 +++ src/include/common/mir/events/input_configuration_event.h	2016-09-18 20:00:37 +0000
@@ -20,7 +20,6 @@
  #define MIR_COMMON_INPUT_CONFIGURATION_EVENT_H_
  #include <chrono>
--#include <limits>
  #include "mir/events/event.h"
@@ -36,11 +35,6 @@
      MirInputDeviceId id() const;
      void set_id(MirInputDeviceId id);
--
--private:
--    MirInputConfigurationAction action_;
--    std::chrono::nanoseconds when_{0};
--    MirInputDeviceId id_{std::numeric_limits<MirInputDeviceId>::max()};
  };
  #endif /* MIR_COMMON_INPUT_CONFIGURATION_EVENT_H_ */
 === modified file 'src/include/common/mir/events/input_device_state_event.h'
 --- src/include/common/mir/events/input_device_state_event.h	2016-05-26 20:59:38 +0000
 +++ src/include/common/mir/events/input_device_state_event.h	2016-09-18 20:00:37 +0000
@@ -21,8 +21,10 @@
  #include <chrono>
  #include <limits>
++#include <unordered_map>
  #include "mir/events/event.h"
++#include "mir/events/input_device_state.h"
  struct MirInputDeviceStateEvent : MirEvent
+ {
@@ -43,33 +45,14 @@
      uint32_t device_count() const;
      MirInputDeviceId device_id(size_t index) const;
      MirPointerButtons device_pointer_buttons(size_t index) const;
--    uint32_t const* device_pressed_keys(size_t index) const;
++
++    // Public API deprecated remove this once it has been removed
++    std::vector<uint32_t> device_pressed_keys(size_t index);
++
++    uint32_t device_pressed_keys_for_index(size_t index, size_t pressed_index) const;
      uint32_t device_pressed_keys_count(size_t index) const;
--    static mir::EventUPtr deserialize(std::string const& bytes);
--    static std::string serialize(MirEvent const* event);
--    MirEvent* clone() const;
--
--    void add_device(MirInputDeviceId id, std::vector<uint32_t> && pressed_keys, MirPointerButtons pointer_buttons);
--
--private:
--    std::chrono::nanoseconds when_{0};
--    MirPointerButtons pointer_buttons_{0};
--    MirInputEventModifiers modifiers_{0};
--
--    float pointer_x{0.0f};
--    float pointer_y{0.0f};
--
--    struct DeviceState
--    {
--        DeviceState(MirInputDeviceId id, std::vector<uint32_t> && pressed_keys, MirPointerButtons buttons)
--            : id{id}, pressed_keys{std::move(pressed_keys)}, pointer_buttons{buttons}
--        {}
--        MirInputDeviceId id;
--        std::vector<uint32_t> pressed_keys;
--        MirPointerButtons pointer_buttons;
--    };
--    std::vector<DeviceState> devices;
++    void set_device_states(std::vector<mir::events::InputDeviceState> const& device_states);
  };
  #endif /* MIR_COMMON_INPUT_DEVICE_STATE_EVENT_H_*/
 === modified file 'src/include/common/mir/events/input_event.h'
 --- src/include/common/mir/events/input_event.h	2016-03-29 03:41:45 +0000
 +++ src/include/common/mir/events/input_event.h	2016-09-18 20:00:37 +0000
@@ -31,7 +31,6 @@
  protected:
      MirInputEvent() = default;
--    explicit MirInputEvent(MirEventType type);
      MirInputEvent(MirInputEvent const& event) = default;
      MirInputEvent& operator=(MirInputEvent const& event) = default;
  };
 === modified file 'src/include/common/mir/events/keyboard_event.h'
 --- src/include/common/mir/events/keyboard_event.h	2016-03-30 18:47:45 +0000
 +++ src/include/common/mir/events/keyboard_event.h	2016-09-18 20:00:37 +0000
@@ -21,9 +21,9 @@
  #include <chrono>
  #include <cstdint>
++#include <vector>
  #include "mir/events/input_event.h"
--#include "mir/cookie/blob.h"
  struct MirKeyboardEvent : MirInputEvent
+ {
@@ -50,20 +50,8 @@
      std::chrono::nanoseconds event_time() const;
      void set_event_time(std::chrono::nanoseconds const& event_time);
--    mir::cookie::Blob cookie() const;
--    void set_cookie(mir::cookie::Blob const& cookie);
--
--private:
--    int32_t device_id_{-1};
--    int32_t source_id_{-1};
--    MirKeyboardAction action_;
--    MirInputEventModifiers modifiers_{0};
--
--    int32_t key_code_{0};
--    int32_t scan_code_{0};
--
--    std::chrono::nanoseconds event_time_{0};
--    mir::cookie::Blob cookie_;
++    std::vector<uint8_t> cookie() const;
++    void set_cookie(std::vector<uint8_t> const& cookie);
  };
  #endif /* MIR_COMMON_KEYBOARD_EVENT_H_ */
 === modified file 'src/include/common/mir/events/keymap_event.h'
 --- src/include/common/mir/events/keymap_event.h	2016-03-30 19:01:10 +0000
 +++ src/include/common/mir/events/keymap_event.h	2016-09-18 20:00:37 +0000
@@ -20,7 +20,6 @@
  #define MIR_COMMON_KEYMAP_EVENT_H_
  #include <xkbcommon/xkbcommon.h>
--#include <limits>
  #include "mir/events/event.h"
@@ -35,26 +34,9 @@
      void set_device_id(MirInputDeviceId id);
      char const* buffer() const;
--    /* FIXME We takes over ownership of the buffer pointer, but we should not be.
--       Either user a unique_ptr here later (when we dont depend on is_trivially_copyable)
--       or copy it into a vector or do a deep copy.
--     */
      void set_buffer(char const* buffer);
--    void free_buffer();
      size_t size() const;
--    void set_size(size_t size);
--
--    /* FIXME Need to handle the special case of Keymap events due to char const* buffer */
--    static mir::EventUPtr deserialize(std::string const& bytes);
--    static std::string serialize(MirEvent const* event);
--    MirEvent* clone() const;
--
--private:
--    int surface_id_{-1};
--    MirInputDeviceId device_id_{std::numeric_limits<MirInputDeviceId>::max()};
--    char const* buffer_{nullptr};
--    size_t size_{0};
  };
  #endif /* MIR_COMMON_KEYMAP_EVENT_H_ */
 === modified file 'src/include/common/mir/events/motion_event.h'
 --- src/include/common/mir/events/motion_event.h	2016-03-30 18:47:45 +0000
 +++ src/include/common/mir/events/motion_event.h	2016-09-18 20:00:37 +0000
@@ -19,35 +19,10 @@
  #ifndef MIR_COMMON_MOTION_EVENT_H_
  #define MIR_COMMON_MOTION_EVENT_H_
--/* TODO: To the moon. */
--#define MIR_INPUT_EVENT_MAX_POINTER_COUNT 16
--
  #include <chrono>
  #include <cstdint>
  #include "mir/events/input_event.h"
--#include "mir/cookie/blob.h"
--
--struct MirMotionPointer
--{
--    int id;
--    float x;
--    float y;
--    float dx;
--    float dy;
--    float touch_major;
--    float touch_minor;
--    float size;
--    float pressure;
--    float orientation;
--    float vscroll;
--    float hscroll;
--    MirTouchTooltype tool_type;
--
--    // TODO: We would like to store this as a MirTouchAction but we still encode pointer actions
--    // here as well.
--    int action;
--};
  struct MirMotionEvent : MirInputEvent
+ {
@@ -68,8 +43,8 @@
      std::chrono::nanoseconds event_time() const;
      void set_event_time(std::chrono::nanoseconds const& event_time);
--    mir::cookie::Blob cookie() const;
--    void set_cookie(mir::cookie::Blob const& blob);
++    std::vector<uint8_t> cookie() const;
++    void set_cookie(std::vector<uint8_t> const& cookie);
      size_t pointer_count() const;
      void set_pointer_count(size_t count);
@@ -123,19 +98,8 @@
      MirPointerEvent const* to_pointer() const;
  private:
--    int32_t device_id_{-1};
--    int32_t source_id_{-1};
--
--    MirInputEventModifiers modifiers_{0};
--
--    MirPointerButtons buttons_{0};
--    std::chrono::nanoseconds event_time_{0};
--    mir::cookie::Blob cookie_;
--
--    size_t pointer_count_{0};
--    MirMotionPointer pointer_coordinates_[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
--    /* "_coordinates" is a misnomer here because there's plenty more info than
--       just coordinates, but renaming it accurately would be an API break */
++    void throw_if_out_of_bounds(size_t index) const;
++
  };
  // These are left empty as they are just aliases for a MirMotionEvent,
 === modified file 'src/include/common/mir/events/orientation_event.h'
 --- src/include/common/mir/events/orientation_event.h	2016-03-30 18:47:45 +0000
 +++ src/include/common/mir/events/orientation_event.h	2016-09-18 20:00:37 +0000
@@ -30,10 +30,6 @@
      MirOrientation direction() const;
      void set_direction(MirOrientation orientation);
--
--private:
--    int surface_id_{-1};
--    MirOrientation direction_;
  };
  #endif /* MIR_COMMON_ORIENTATION_EVENT_H_ */
 === modified file 'src/include/common/mir/events/prompt_session_event.h'
 --- src/include/common/mir/events/prompt_session_event.h	2016-03-29 03:41:45 +0000
 +++ src/include/common/mir/events/prompt_session_event.h	2016-09-18 20:00:37 +0000
@@ -27,9 +27,6 @@
      MirPromptSessionState new_state() const;
      void set_new_state(MirPromptSessionState state);
--
--private:
--    MirPromptSessionState new_state_;
  };
  #endif /* MIR_COMMON_PROMPT_SESSION_EVENT_H_ */
 === modified file 'src/include/common/mir/events/resize_event.h'
 --- src/include/common/mir/events/resize_event.h	2016-03-30 18:47:45 +0000
 +++ src/include/common/mir/events/resize_event.h	2016-09-18 20:00:37 +0000
@@ -33,11 +33,6 @@
      int height() const;
      void set_height(int height);
--
--private:
--    int surface_id_{-1};
--    int width_{0};
--    int height_{0};
  };
  #endif /* MIR_COMMON_RESIZE_EVENT_H_ */
 === modified file 'src/include/common/mir/events/surface_event.h'
 --- src/include/common/mir/events/surface_event.h	2016-03-29 03:41:45 +0000
 +++ src/include/common/mir/events/surface_event.h	2016-09-18 20:00:37 +0000
@@ -33,11 +33,6 @@
      int value() const;
      void set_value(int value);
--
--private:
--    int id_{0};
--    MirSurfaceAttrib attrib_;
--    int value_{0};
  };
  #endif /* MIR_COMMON_SURFACE_EVENT_H_ */
 === modified file 'src/include/common/mir/events/surface_output_event.h'
 --- src/include/common/mir/events/surface_output_event.h	2016-03-30 19:01:10 +0000
 +++ src/include/common/mir/events/surface_output_event.h	2016-09-18 20:00:37 +0000
@@ -20,7 +20,6 @@
  #define MIR_COMMON_SURFACE_OUTPUT_EVENT_H_
  #include <cstdint>
--#include <limits>
  #include "mir/events/event.h"
@@ -42,13 +41,6 @@
      uint32_t output_id() const;
      void set_output_id(uint32_t id);
--
--private:
--    int surface_id_{-1};
--    int dpi_{0};
--    float scale_{0.0f};
--    MirFormFactor form_factor_;
--    uint32_t output_id_{std::numeric_limits<uint32_t>::max()};
  };
  #endif /* MIR_COMMON_SURFACE_OUTPUT_EVENT_H_ */
 === modified file 'src/server/graphics/nested/input_platform.cpp'
 --- src/server/graphics/nested/input_platform.cpp	2016-09-01 12:28:46 +0000
 +++ src/server/graphics/nested/input_platform.cpp	2016-09-18 20:00:37 +0000
@@ -229,7 +229,7 @@
+                 {
                      unknown_device_events[id].emplace_back(
                          std::piecewise_construct,
--                        std::forward_as_tuple(event.clone(), [](MirEvent* e){delete e;}),
++                        std::forward_as_tuple(new MirEvent(event), [](MirEvent* e){delete e;}),
                          std::forward_as_tuple(area));
+                 }
+             }
@@ -247,9 +247,13 @@
+                         {
                              auto dest = it->second->destination;
                              auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
--                            auto const* scan_codes = mir_input_device_state_event_device_pressed_keys(device_state, index);
++                            std::vector<uint32_t> scan_codes;
++                            for (uint32_t i = 0; i < key_count; i++)
++                            {
++                                scan_codes.push_back(mir_input_device_state_event_device_pressed_keys_for_index(device_state, index, i));
++                            }
--                            dest->key_state({scan_codes, scan_codes + key_count});
++                            dest->key_state(scan_codes);
                              dest->pointer_state(
                                  mir_input_device_state_event_device_pointer_buttons(device_state, index));
+                         }
 === modified file 'src/server/input/android/input_sender.cpp'
 --- src/server/input/android/input_sender.cpp	2016-06-03 08:39:59 +0000
 +++ src/server/input/android/input_sender.cpp	2016-09-18 20:00:37 +0000
@@ -38,6 +38,23 @@
  namespace droidinput = android;
++namespace
++{
++// FIXME Temp, only needed to use the android input_sender/receiver
++mir::cookie::Blob convert_cookie_to_blob(std::vector<uint8_t> const& cookie)
++{
++    if (cookie.size() > mir::cookie::default_blob_size)
++    {
++        BOOST_THROW_EXCEPTION(std::runtime_error("The cookie size must be less the mir::cookie::default_blob_size"));
++    }
++
++    mir::cookie::Blob cookie_blob{{0}};
++    std::copy(std::begin(cookie), std::end(cookie), std::begin(cookie_blob));
++
++    return cookie_blob;
++}
++}
++
  mia::InputSender::InputSender(std::shared_ptr<mir::compositor::Scene> const& scene,
                                std::shared_ptr<mir::MainLoop> const& main_loop,
                                std::shared_ptr<InputReport> const& report)
@@ -256,7 +273,7 @@
                                       mir_keyboard_event_scan_code(key_event),
                                       mia::android_modifiers_from_mir(mir_keyboard_event_modifiers(key_event)),
                                       repeat_count,
--                                     event.to_input()->to_keyboard()->cookie(),
++                                     convert_cookie_to_blob(event.to_input()->to_keyboard()->cookie()),
                                       event_time,
                                       event_time);
+ }
@@ -264,8 +281,8 @@
  droidinput::status_t mia::InputSender::ActiveTransfer::send_touch_event(uint32_t seq, MirEvent const& event)
+ {
      droidinput::status_t ret = droidinput::OK;
--    droidinput::PointerCoords coords[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
--    droidinput::PointerProperties properties[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
++    droidinput::PointerCoords coords[mir::capnp::MotionSetEvent::MAX_COUNT];
++    droidinput::PointerProperties properties[mir::capnp::MotionSetEvent::MAX_COUNT];
      auto input_event = mir_event_get_input_event(&event);
      auto touch = mir_input_event_get_touch_event(input_event);
      std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
@@ -333,7 +350,8 @@
          ret = publisher.publishMotionEvent(seq, mir_input_event_get_device_id(input_event), AINPUT_SOURCE_TOUCHSCREEN,
                                             state_change.android_action, flags, edge_flags,
                                             mia::android_modifiers_from_mir(mir_touch_event_modifiers(touch)),
--                                           button_state, x_offset, y_offset, x_precision, y_precision, event.to_input()->to_motion()->cookie(),
++                                           button_state, x_offset, y_offset, x_precision, y_precision,
++                                           convert_cookie_to_blob(event.to_input()->to_motion()->cookie()),
                                             event_time, event_time, contacts_in_event, properties, coords);
+     }
@@ -370,7 +388,8 @@
          mia::android_pointer_action_from_mir(mir_pointer_event_action(pointer), mir_pointer_event_buttons(pointer)),
          flags, edge_flags, mia::android_modifiers_from_mir(mir_pointer_event_modifiers(pointer)),
          mia::android_pointer_buttons_from_mir(mir_pointer_event_buttons(pointer)), x_offset, y_offset, x_precision,
--        y_precision, event.to_input()->to_motion()->cookie(), event_time, event_time, 1, &pointer_properties, &pointer_coord);
++        y_precision, convert_cookie_to_blob(event.to_input()->to_motion()->cookie()),
++        event_time, event_time, 1, &pointer_properties, &pointer_coord);
+ }
 === modified file 'src/server/input/default_event_builder.cpp'
 --- src/server/input/default_event_builder.cpp	2016-06-03 08:39:59 +0000
 +++ src/server/input/default_event_builder.cpp	2016-09-18 20:00:37 +0000
@@ -59,10 +59,8 @@
          auto mev = event.to_input()->to_motion();
          auto const cookie = cookie_authority->make_cookie(mev->event_time().count());
          auto const serialized_cookie = cookie->serialize();
--        mir::cookie::Blob event_cookie;
--        std::copy_n(std::begin(serialized_cookie), event_cookie.size(), std::begin(event_cookie));
--        mev->set_cookie(event_cookie);
++        mev->set_cookie(serialized_cookie);
+     }
      me::add_touch(event, touch_id, action, tooltype, x_axis_value, y_axis_value, pressure_value, touch_major_value,
 === modified file 'src/server/input/key_repeat_dispatcher.cpp'
 --- src/server/input/key_repeat_dispatcher.cpp	2016-05-03 06:55:25 +0000
 +++ src/server/input/key_repeat_dispatcher.cpp	2016-09-18 20:00:37 +0000
@@ -173,9 +173,7 @@
                  new_kev.set_event_time(std::chrono::steady_clock::now().time_since_epoch());
                  auto const cookie = cookie_authority->make_cookie(new_kev.event_time().count());
                  auto const serialized_cookie = cookie->serialize();
--                mir::cookie::Blob event_cookie;
--                std::copy_n(std::begin(serialized_cookie), event_cookie.size(), std::begin(event_cookie));
--                new_kev.set_cookie(event_cookie);
++                new_kev.set_cookie(serialized_cookie);
                  next_dispatcher->dispatch(new_kev);
                  capture_alarm->reschedule_in(repeat_delay);
 === modified file 'src/server/input/validator.cpp'
 --- src/server/input/validator.cpp	2016-05-03 06:55:25 +0000
 +++ src/server/input/validator.cpp	2016-09-18 20:00:37 +0000
@@ -56,7 +56,8 @@
  namespace
+ {
--void delete_event(MirEvent *e) { mir_event_unref(e); }
++void delete_event(MirEvent *e) { delete e; }
++
  mir::EventUPtr make_event_uptr(MirEvent *e)
+ {
      return mir::EventUPtr(e, delete_event);
@@ -64,9 +65,7 @@
  mir::EventUPtr copy_event(MirTouchEvent const* ev)
+ {
--    MirTouchEvent* ret = new MirTouchEvent;
--    memcpy(ret, ev, sizeof(MirTouchEvent));
--    return make_event_uptr(ret);
++    return make_event_uptr(new MirTouchEvent(*ev));
+ }
  // Return a copy of ev with existing touch actions converted to change.
 === modified file 'tests/unit-tests/client/input/test_android_input_receiver.cpp'
 --- tests/unit-tests/client/input/test_android_input_receiver.cpp	2016-05-03 06:55:25 +0000
 +++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2016-09-18 20:00:37 +0000
@@ -230,7 +230,7 @@
                                     std::make_shared<mircv::XKBMapper>(),
                                     [&ev, &handler_called](MirEvent* event)
+                                    {
--                                       ev.reset(event->clone());
++                                       ev.reset(new MirEvent(*event));
                                         handler_called = true;
                                     },
                                     std::make_shared<mircv::NullInputReceiverReport>(),
 === modified file 'tests/unit-tests/input/android/test_android_input_sender.cpp'
 --- tests/unit-tests/input/android/test_android_input_sender.cpp	2016-06-07 21:10:34 +0000
 +++ tests/unit-tests/input/android/test_android_input_sender.cpp	2016-09-18 20:00:37 +0000
@@ -503,7 +503,8 @@
      const auto timestamp = std::chrono::nanoseconds(10);
      register_surface();
      std::vector<mir::events::InputDeviceState> states;
--    states.push_back({MirInputDeviceId{23}, {50, 60, 80}, 0});
++    std::vector<uint32_t> const pressed_keys = {50, 60, 80};
++    states.push_back({MirInputDeviceId{23}, pressed_keys, 0});
      states.push_back({MirInputDeviceId{21}, {}, mir_pointer_button_primary});
      auto device_state = mir::events::make_event(timestamp, mir_pointer_button_primary, mir_input_event_modifier_caps_lock,
@@ -522,10 +523,13 @@
      EXPECT_THAT(mir_input_device_state_event_device_count(input_device_state), Eq(2));
      EXPECT_THAT(mir_input_device_state_event_device_id(input_device_state, 0), Eq(MirInputDeviceId{23}));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_count(input_device_state, 0), Eq(3));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[0], Eq(50));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[1], Eq(60));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(input_device_state, 0)[2], Eq(80));
++    auto keys_count = mir_input_device_state_event_device_pressed_keys_count(input_device_state, 0);
++    EXPECT_THAT(keys_count, Eq(3));
++
++    for (uint32_t i = 0; i < keys_count; i++)
++    {
++        EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_for_index(input_device_state, 0, i), Eq(pressed_keys[i]));
++    }
      EXPECT_THAT(mir_input_device_state_event_device_pointer_buttons(input_device_state, 0), 0);
      EXPECT_THAT(mir_input_device_state_event_device_id(input_device_state, 1), Eq(MirInputDeviceId{21}));
 === modified file 'tests/unit-tests/input/test_event_builders.cpp'
 --- tests/unit-tests/input/test_event_builders.cpp	2016-05-26 20:59:38 +0000
 +++ tests/unit-tests/input/test_event_builders.cpp	2016-09-18 20:00:37 +0000
@@ -189,12 +189,14 @@
      auto const pos_y = 53.2f;
      auto const button_state = mir_pointer_button_primary|mir_pointer_button_secondary;
      auto const modifiers = mir_input_event_modifier_ctrl_right | mir_input_event_modifier_ctrl;
++    std::vector<uint32_t> const pressed_keys = {KEY_LEFTALT, KEY_M};
++
      auto ev = mev::make_event(timestamp,
                                button_state,
                                modifiers,
                                pos_x,
                                pos_y,
--                              {mev::InputDeviceState{MirInputDeviceId{3}, {KEY_LEFTALT, KEY_M}, 0},
++                              {mev::InputDeviceState{MirInputDeviceId{3}, pressed_keys, 0},
                                 mev::InputDeviceState{MirInputDeviceId{2}, {}, button_state}});
      EXPECT_THAT(mir_event_get_type(ev.get()), Eq(mir_event_type_input_device_state));
@@ -208,9 +210,14 @@
      EXPECT_THAT(mir_input_device_state_event_device_count(ids_event), Eq(2));
      EXPECT_THAT(mir_input_device_state_event_device_id(ids_event, 0), Eq(MirInputDeviceId{3}));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_count(ids_event, 0), Eq(2));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(ids_event, 0)[0], Eq(KEY_LEFTALT));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(ids_event, 0)[1], Eq(KEY_M));
++
++    auto const pressed_keys_count = mir_input_device_state_event_device_pressed_keys_count(ids_event, 0);
++    EXPECT_THAT(pressed_keys_count, Eq(2));
++    for (uint32_t i = 0; i < pressed_keys_count; i++)
++    {
++        EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_for_index(ids_event, 0, i), Eq(pressed_keys[i]));
++    }
++
      EXPECT_THAT(mir_input_device_state_event_device_pointer_buttons(ids_event, 0), Eq(0));
      EXPECT_THAT(mir_input_device_state_event_device_id(ids_event, 1), Eq(MirInputDeviceId{2}));
@@ -252,6 +259,7 @@
      auto const pos_y = 0.0f;
      auto const button_state = mir_pointer_button_primary | mir_pointer_button_secondary;
      auto const modifiers = mir_input_event_modifier_none;
++    std::vector<uint32_t> const pressed_keys = {KEY_RIGHTALT, KEY_LEFTSHIFT, KEY_Q};
      auto ev = mev::make_event(timestamp,
                                button_state,
                                modifiers,
@@ -259,7 +267,7 @@
                                pos_y,
                                {mev::InputDeviceState{MirInputDeviceId{0}, {}, mir_pointer_button_primary},
                                 mev::InputDeviceState{MirInputDeviceId{2}, {}, mir_pointer_button_secondary},
--                               mev::InputDeviceState{MirInputDeviceId{3}, {KEY_RIGHTALT, KEY_LEFTSHIFT, KEY_Q}, 0}});
++                               mev::InputDeviceState{MirInputDeviceId{3}, pressed_keys, 0}});
      auto encoded = MirEvent::serialize(ev.get());
@@ -269,8 +277,11 @@
      auto ids_event = mir_event_get_input_device_state_event(deserialzed_event.get());
      EXPECT_THAT(mir_input_device_state_event_device_count(ids_event), Eq(3));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_count(ids_event, 2), Eq(3));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(ids_event, 2)[0], Eq(KEY_RIGHTALT));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(ids_event, 2)[1], Eq(KEY_LEFTSHIFT));
--    EXPECT_THAT(mir_input_device_state_event_device_pressed_keys(ids_event, 2)[2], Eq(KEY_Q));
++    auto pressed_keys_count = mir_input_device_state_event_device_pressed_keys_count(ids_event, 2);
++    EXPECT_THAT(pressed_keys_count, Eq(3));
++
++    for (uint32_t i = 0; i < pressed_keys_count; i++)
++    {
++        EXPECT_THAT(mir_input_device_state_event_device_pressed_keys_for_index(ids_event, 2, i), Eq(pressed_keys[i]));
++    }
+ }
 === modified file 'tests/unit-tests/input/test_surface_input_dispatcher.cpp'
 --- tests/unit-tests/input/test_surface_input_dispatcher.cpp	2016-06-10 12:55:53 +0000
 +++ tests/unit-tests/input/test_surface_input_dispatcher.cpp	2016-09-18 20:00:37 +0000
@@ -264,7 +264,7 @@
      FakeKeyboard keyboard;
      auto event = keyboard.press();
--    EXPECT_CALL(*surface, consume(mt::MirKeyboardEventMatches(ByRef(*event)))).Times(1);
++    EXPECT_CALL(*surface, consume(mt::MirKeyboardEventMatches(event.get()))).Times(1);
      dispatcher.start();
 === modified file 'tests/unit-tests/input/test_validator.cpp'
 --- tests/unit-tests/input/test_validator.cpp	2016-05-03 06:55:25 +0000
 +++ tests/unit-tests/input/test_validator.cpp	2016-09-18 20:00:37 +0000
@@ -87,9 +87,9 @@
      add_another_touch(inserted_down_id1, 1, mir_touch_action_down);
      InSequence seq;
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id0))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id0.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch.get())));
      rewriter.validate_and_dispatch(*touch);
+ }
@@ -108,10 +108,10 @@
      add_another_touch(inserted_release, 1, mir_touch_action_up);
      InSequence seq;
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_release))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_3))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_release.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_3.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
@@ -138,12 +138,12 @@
      add_another_touch(inserted_release_id0, 2, mir_touch_action_change);
      InSequence seq;
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_3))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_release_id1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_release_id0))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_4))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_3.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_release_id1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_release_id0.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_4.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
@@ -169,12 +169,12 @@
      auto inserted_down_id2 = make_touch(0, mir_touch_action_change);
      add_another_touch(inserted_down_id2, 2, mir_touch_action_down);
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_3))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_release_id1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_4))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_3.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_release_id1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_4.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
@@ -196,11 +196,11 @@
      auto inserted_down_id2 = make_touch(1, mir_touch_action_change);
      add_another_touch(inserted_down_id2, 2, mir_touch_action_down);
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_up_id0))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_3))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_up_id0.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_3.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
@@ -226,12 +226,12 @@
      add_another_touch(inserted_down_id1, 1, mir_touch_action_down);
      InSequence seq;
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_3))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_4))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_5))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_3.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_4.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_5.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
@@ -252,10 +252,10 @@
      auto inserted_up_id0 = make_touch(0, mir_touch_action_up);
      auto inserted_down_id1 = make_touch(1, mir_touch_action_down);
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_up_id0))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*inserted_down_id1))));
--    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(ByRef(*touch_2))));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_up_id0.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(inserted_down_id1.get())));
++    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(touch_2.get())));
      rewriter.validate_and_dispatch(*touch_1);
      rewriter.validate_and_dispatch(*touch_2);
 === modified file 'tests/unit-tests/scene/test_application_session.cpp'
 --- tests/unit-tests/scene/test_application_session.cpp	2016-08-10 10:43:39 +0000
 +++ tests/unit-tests/scene/test_application_session.cpp	2016-09-18 20:00:37 +0000
@@ -897,14 +897,16 @@
+ {
      using namespace ::testing;
--    //MirEvent* event;
--    std::unique_ptr<MirEvent> event;
++    MirSurfaceOutputEvent event;
      bool event_received{false};
      EXPECT_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
          .WillOnce(Invoke([&event, &event_received](MirEvent const& ev)
+                          {
--                             event.reset(ev.clone());
++                             if (event.type() == mir_event_type_surface_output)
++                             {
++                                 event = *ev.to_surface_output();
++                             }
                               event_received = true;
                           }));
@@ -922,7 +924,7 @@
      auto surface = app_session.surface(surf_id);
      ASSERT_TRUE(event_received);
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
+ }
  TEST_F(ApplicationSessionSurfaceOutput, sends_correct_surface_details_to_surface)
@@ -931,13 +933,16 @@
      std::array<TestOutput const*, 2> outputs{{ &high_dpi, &projector }};
--    std::array<std::unique_ptr<MirEvent>, 2> event;
++    std::array<MirSurfaceOutputEvent, 2> event;
      int events_received{0};
      ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
          .WillByDefault(Invoke([&event, &events_received](MirEvent const& ev)
+                          {
--                             event[events_received].reset(ev.clone());
++                             if (ev.type() == mir_event_type_surface_output)
++                             {
++                                 event[events_received] = *ev.to_surface_output();
++                             }
                               ++events_received;
                           }));
@@ -974,8 +979,8 @@
      for (int i = 0; i < 2 ; ++i)
+     {
--        EXPECT_THAT(event[i]->to_surface_output()->surface_id(), Eq(ids[i].as_value()));
--        EXPECT_THAT(event[i].get(), SurfaceOutputEventFor(*outputs[i]));
++        EXPECT_THAT(event[i].to_surface_output()->surface_id(), Eq(ids[i].as_value()));
++        EXPECT_THAT(&event[i], SurfaceOutputEventFor(*outputs[i]));
+     }
+ }
@@ -985,13 +990,16 @@
      std::array<TestOutput const*, 2> outputs{{ &projector, &high_dpi }};
--    std::unique_ptr<MirEvent> event;
++    MirSurfaceOutputEvent event;
      bool event_received{false};
      ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
          .WillByDefault(Invoke([&event, &event_received](MirEvent const& ev)
+                               {
--                                  event.reset(ev.clone());
++                                  if (ev.type() == mir_event_type_surface_output)
++                                  {
++                                      event = *ev.to_surface_output();
++                                  }
                                    event_received = true;
                                }));
@@ -1020,8 +1028,8 @@
      ASSERT_TRUE(event_received);
--    EXPECT_THAT(event->to_surface_output()->surface_id(), Eq(id.as_value()));
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(event.to_surface_output()->surface_id(), Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
+ }
  TEST_F(ApplicationSessionSurfaceOutput, surfaces_on_edges_get_correct_values)
@@ -1030,13 +1038,16 @@
      std::array<TestOutput const*, 2> outputs{{ &projector, &high_dpi }};
--    std::unique_ptr<MirEvent> event;
++    MirSurfaceOutputEvent event;
      bool event_received{false};
      ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
          .WillByDefault(Invoke([&event, &event_received](MirEvent const& ev)
+                               {
--                                  event.reset(ev.clone());
++                                  if (ev.type() == mir_event_type_surface_output)
++                                  {
++                                      event = *ev.to_surface_output();
++                                  }
                                    event_received = true;
                                }));
@@ -1064,21 +1075,21 @@
      surface->move_to({outputs[0]->width - ((surface->size().width.as_uint32_t()) / 2), 100});
      ASSERT_TRUE(event_received);
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
      event_received = false;
      // This should be *just* entirely on the projector
      surface->move_to({outputs[0]->width - surface->size().width.as_uint32_t(), 100});
      ASSERT_TRUE(event_received);
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(projector));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(projector));
      event_received = false;
      // This should have a single pixel overlap on the high_dpi
      surface->move_to({outputs[0]->width - (surface->size().width.as_uint32_t() - 1), 100});
      ASSERT_TRUE(event_received);
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
+ }
  TEST_F(ApplicationSessionSurfaceOutput, sends_surface_output_event_on_move)
@@ -1087,14 +1098,17 @@
      std::array<TestOutput const*, 2> outputs {{ &projector, &high_dpi }};
--    std::unique_ptr<MirEvent> event;
++    MirSurfaceOutputEvent event;
      int events_received{0};
      ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
          .WillByDefault(Invoke([&event, &events_received](MirEvent const& ev)
+                               {
--                                  event.reset(ev.clone());
++                                  if (ev.type() == mir_event_type_surface_output)
++                                  {
++                                      event = *ev.to_surface_output();
++                                  }
                                    events_received++;
                                }));
@@ -1125,8 +1139,8 @@
      ASSERT_THAT(events_received, Ge(1));
      auto events_expected = events_received + 1;
--    EXPECT_THAT(event->to_surface_output()->surface_id(), Eq(id.as_value()));
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(event.to_surface_output()->surface_id(), Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
      // Now solely on the left output
      surface->move_to({0, 0});
@@ -1134,8 +1148,8 @@
      ASSERT_THAT(events_received, Eq(events_expected));
      events_expected++;
--    EXPECT_THAT(event->to_surface_output()->surface_id(), Eq(id.as_value()));
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(projector));
++    EXPECT_THAT(event.to_surface_output()->surface_id(), Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(projector));
      // Now solely on the right output
      surface->move_to({outputs[0]->width + 100, 100});
@@ -1143,8 +1157,8 @@
      ASSERT_THAT(events_received, Eq(events_expected));
      events_expected++;
--    EXPECT_THAT(event->to_surface_output()->surface_id(), Eq(id.as_value()));
--    EXPECT_THAT(event.get(), SurfaceOutputEventFor(high_dpi));
++    EXPECT_THAT(event.to_surface_output()->surface_id(), Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
+ }
  TEST_F(ApplicationSessionSurfaceOutput, sends_surface_output_event_on_move_only_if_changed)
 === modified file 'tests/unit-tests/scene/test_surface.cpp'
 --- tests/unit-tests/scene/test_surface.cpp	2016-08-24 02:09:08 +0000
 +++ tests/unit-tests/scene/test_surface.cpp	2016-09-18 20:00:37 +0000
@@ -410,8 +410,8 @@
      mev::add_touch(*touch_event, 0, mir_touch_action_down, mir_touch_tooltype_finger, 0, 0,
 , 0, 0, 0);
--    EXPECT_CALL(mock_sender, send_event(mt::MirKeyboardEventMatches(ByRef(*key_event)), _)).Times(1);
--    EXPECT_CALL(mock_sender, send_event(mt::MirTouchEventMatches(ByRef(*touch_event)), _)).Times(1);
++    EXPECT_CALL(mock_sender, send_event(mt::MirKeyboardEventMatches(key_event.get()), _)).Times(1);
++    EXPECT_CALL(mock_sender, send_event(mt::MirTouchEventMatches(touch_event.get()), _)).Times(1);
      surface.consume(key_event.get());
      surface.consume(touch_event.get());
 === modified file 'tests/unit-tests/scene/test_surface_impl.cpp'
 --- tests/unit-tests/scene/test_surface_impl.cpp	2016-08-24 02:09:08 +0000
 +++ tests/unit-tests/scene/test_surface_impl.cpp	2016-09-18 20:00:37 +0000
@@ -166,12 +166,6 @@
      EXPECT_EQ(mir_surface_state_fullscreen, surface->state());
+ }
--bool operator==(MirEvent const& a, MirEvent const& b)
--{
--    // We will always fill unused bytes with zero, so memcmp is accurate...
--    return !memcmp(&a, &b, sizeof(MirEvent));
--}
--
  TEST_F(Surface, clamps_undersized_resize)
+ {
      using namespace testing;
@@ -255,6 +249,10 @@
      surface->configure(mir_surface_attrib_focus, mir_surface_focused);
      surface->configure(mir_surface_attrib_focus, mir_surface_unfocused);
+ }
++MATCHER_P(MirCloseSurfaceEventMatches, event, "")
++{
++    return arg.type() == event->type();
++}
  TEST_F(Surface, emits_client_close_events)
+ {
@@ -269,7 +267,7 @@
      MirCloseSurfaceEvent e;
      e.to_close_surface()->set_surface_id(stub_id.as_value());
--    EXPECT_CALL(*sink, handle_event(Eq(ByRef(e)))).Times(1);
++    EXPECT_CALL(*sink, handle_event(MirCloseSurfaceEventMatches(&e))).Times(1);
      surface->request_client_surface_close();
+ }