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

[Brandon Schaefer]

Move from a union to CapnProto structure for the MirEvent.

This will give us a serializable structure in which we can pass the mir event from server --> client and vis versa (once the rpc parts are fixed).
This will allow moving over to a capnproto rpc much easier as well.

We are still using the android input sender/receiver. The next step is to remove that, and add our own input sender/receiver using CapnProto serialization.

Move from a union to CapnProto structure for the MirEvent.

This will give us a serializable structure in which we can pass the mir event from server --> client and vis versa (once the rpc parts are fixed).
This will allow moving over to a capnproto rpc much easier as well.

We are still using the android input sender/receiver. The next step is to remove that, and add our own input sender/receiver using CapnProto serialization.

80% of the branch is just changing accessing points, while the other 20% is the main part of how to create a CapnProto event.

CapnProto events are built using an area pool for memory. The message (which is part of the mir event) is what actually holds the memory. The mir::capnp::Event is just the way to correctly access that memory chunk. The only way to copy is to copy from a reader which makes a deep copy of everything. It is not possible to do a shallow copy (for good reasons).

A couple of things:
Preference: (*ptr)->asReader() vs ptr->event.asReader()?
static_cast<..> Enums from C++ enum class --> C enums. // We need to test they are aligned!

[lp:~brandontschaefer/mir/capnproto-event]

3393. By Brandon Schaefer on 2016-03-15

* Add a test to compare enums of cpanp vs the public C interface
* Move from event.event to event->
* Rename some of the enums in capnp from redundant namespaces

[Brandon Schaefer (brandontschaefer)]

This would be a good time to change names of the event stuctures! ie. I've change MotionEvent into MotionEventSet and PointerCoords to Motions etc.

[lp:~brandontschaefer/mir/capnproto-event]

3394. By Brandon Schaefer on 2016-03-15

* Change unit test to a static assert so we see the issues when compiling.
* Rename swapinterval to swapInterval
* Force the LGPL check for src/capnproto

[Daniel van Vugt (vanvugt)]

Interesting.

Loosely, resubmit, or wait a bit. We just want to make sure 0.21 gets branched before this lands.

[Daniel van Vugt (vanvugt)]

review: Needs Resubmitting

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

FAILED: Continuous integration, rev:3394
https://mir-jenkins.ubuntu.com/job/mir-ci/587/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/487/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/517
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/509
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/509
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/497/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/497/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/497/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/497/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/497/console

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

review: Needs Fixing (continuous-integration)

[lp:~brandontschaefer/mir/capnproto-event]

3395. By Brandon Schaefer on 2016-03-16

* Should add the new lib depend to deb

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

FAILED: Continuous integration, rev:3395
https://mir-jenkins.ubuntu.com/job/mir-ci/601/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/502/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/532
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/524
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/524
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/512/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/512/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/512/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/512/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/512/console

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

review: Needs Fixing (continuous-integration)

[lp:~brandontschaefer/mir/capnproto-event]

3396. By Brandon Schaefer on 2016-03-16

* Need to have a backup lookup for capnproto on vivid

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

FAILED: Continuous integration, rev:3396
https://mir-jenkins.ubuntu.com/job/mir-ci/603/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/504/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/534
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/526
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/526
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/514/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/514/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/514/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/514/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/514/console

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

review: Needs Fixing (continuous-integration)

[lp:~brandontschaefer/mir/capnproto-event]

3397. By Brandon Schaefer on 2016-03-16

* Missed the compiler library
* QUIET so the find doesnt add noise that isnt needed

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

FAILED: Continuous integration, rev:3397
https://mir-jenkins.ubuntu.com/job/mir-ci/604/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/505/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/535
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/527
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/527
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/515/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/515
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/515/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/515/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/515/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/515/console

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

review: Needs Fixing (continuous-integration)

[Cemil Azizoglu (cemil-azizoglu)]

Took a look at this and after discussion between Chris, Brandon and myself we came to the conclusion that this MP could be broken up into the following logical pieces :

- Change MirEvent from 'union' to 'struct' similar to http://pastebin.ubuntu.com/15404617 and make all the necessary changes for that
- Add setters/getters for MirEvent et friends, possibly turning them into 'class' and making members private
- Add capnproto bits

review: Needs Resubmitting

Unmerged revisions

3397. By Brandon Schaefer on 2016-03-16

* Missed the compiler library
* QUIET so the find doesnt add noise that isnt needed

3396. By Brandon Schaefer on 2016-03-16

* Need to have a backup lookup for capnproto on vivid

3395. By Brandon Schaefer on 2016-03-16

* Should add the new lib depend to deb

3394. By Brandon Schaefer on 2016-03-15

* Change unit test to a static assert so we see the issues when compiling.
* Rename swapinterval to swapInterval
* Force the LGPL check for src/capnproto

3393. By Brandon Schaefer on 2016-03-15

* Add a test to compare enums of cpanp vs the public C interface
* Move from event.event to event->
* Rename some of the enums in capnp from redundant namespaces

3392. By Brandon Schaefer on 2016-03-15

* Couple small fixes

3391. By Brandon Schaefer on 2016-03-15

* Merge Trunk

3390. By Brandon Schaefer on 2016-03-15

* Add back the missing test commented out

3389. By Brandon Schaefer on 2016-03-15

* Switch over to using capnproto for our event structure.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-03-16 06:59:01 +0000
+++ CMakeLists.txt	2016-03-16 18:27:24 +0000
@@ -188,7 +188,9 @@
 find_package(EGL REQUIRED)
 find_package(GLESv2 REQUIRED)
 find_package(GLM REQUIRED)
-find_package(Protobuf REQUIRED )
+find_package(Protobuf REQUIRED)
+# Vivid doesnt have the newer capnproto, so it doesnt have a *.cmake to find (cant require)
+find_package(CapnProto QUIET)
 find_package(GLog REQUIRED)
 find_package(GFlags REQUIRED)
 find_package(LTTngUST REQUIRED)
@@ -245,7 +247,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-03-16 06:59:01 +0000
+++ debian/control	2016-03-16 18:27:24 +0000
@@ -45,6 +45,8 @@
                python3:any,
                dh-python,
                nettle-dev,
+               libcapnp-dev,
+               capnproto
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/mir
 # If you aren't a member of ~mir-team but need to upload packaging changes,

=== modified file 'include/client/mir_toolkit/events/event.h'
--- include/client/mir_toolkit/events/event.h	2016-03-14 10:13:49 +0000
+++ include/client/mir_toolkit/events/event.h	2016-03-16 18:27:24 +0000
@@ -60,7 +60,7 @@
 
 typedef struct MirCookie MirCookie;
 
-typedef union MirEvent MirEvent;
+typedef struct MirEvent MirEvent;
 
 #ifdef __cplusplus
 }

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-03-14 10:13:49 +0000
+++ src/CMakeLists.txt	2016-03-16 18:27:24 +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-03-16 18:27:24 +0000
@@ -0,0 +1,76 @@
+# 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 <[e-mail]>
+
+if (DEFINED CAPNP_LIBRARIES_LITE)
+  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})
+# TODO Remove this entire else statement once vivid has libproto 0.5.3 or greater
+else ()
+  find_library(CAPNPLIB capnp)
+  if(NOT CAPNPLIB)
+    message(FATAL_ERROR "libcapnp-dev not found.")
+  endif()
+
+  find_library(KJLIB kj)
+  if(NOT KJLIB)
+    message(FATAL_ERROR "capnproto not found.")
+  endif()
+
+  find_program(CAPNPC_BIN capnpc)
+  if(NOT CAPNPC_BIN)
+    message(FATAL_ERROR "Capnp compiler not found.")
+  endif()
+  set(CAPNPC_FLAGS "" CACHE STRING "Extra flags for capnpc.")
+
+  set(CAPNPROTO_FILES ${CAPNPROTO_FILES}
+      "${CMAKE_CURRENT_SOURCE_DIR}/mir_event.capnp")
+
+  # Custom rules to compile .capnp files
+  # Taken from lp:unity-scopes-api
+  foreach(file ${CAPNPROTO_FILES})
+
+    string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" build_dir ${file})
+    get_filename_component(build_dir ${build_dir} PATH)
+
+    get_filename_component(proto_file ${file} NAME)
+    string(REPLACE ".capnp" ".capnp.c++" src_file ${proto_file})
+    string(REPLACE ".capnp" ".capnp.h" hdr_file ${proto_file})
+
+    set(src_file ${build_dir}/${src_file})
+    set(hdr_file ${build_dir}/${hdr_file})
+
+    set(CAPNPROTO_HDRS ${CAPNPROTO_HDRS} ${hdr_file})
+    set(CAPNPROTO_SRC ${CAPNPROTO_SRC} ${src_file})
+  endforeach()
+
+  add_custom_command(OUTPUT  ${CAPNPROTO_SRC} ${CAPNPROTO_HDRS}
+                     DEPENDS ${CAPNPROTO_FILES}
+                     COMMAND ${CAPNPC_BIN} ${CAPNPC_FLAGS} -oc++:${CMAKE_BINARY_DIR} --src-prefix=${CMAKE_SOURCE_DIR} ${CAPNPROTO_FILES})
+
+  add_library(mircapnproto STATIC ${CAPNPROTO_SRC})
+  target_link_libraries(mircapnproto ${CAPNPLIB} ${KJLIB})
+endif()
+
+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-03-16 18:27:24 +0000
@@ -0,0 +1,204 @@
+# 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 <[e-mail]>
+
+@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 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 MotionEventSet
+{
+    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 Event
+{
+    union
+    {
+        key @0 :KeyboardEvent;
+        motionSet @1 :MotionEventSet;
+        surface @2 :SurfaceEvent;
+        resize @3 :ResizeEvent;
+        promptSession @4 :PromptSessionEvent;
+        orientation @5 :OrientationEvent;
+        closeSurface @6 :CloseSurfaceEvent;
+        keymap @7 :KeymapEvent;
+        inputConfiguration @8 :InputConfigurationEvent;
+        surfaceOutput @9 :SurfaceOutputEvent;
+    }
+}

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2016-03-16 06:59:01 +0000
+++ src/client/CMakeLists.txt	2016-03-16 18:27:24 +0000
@@ -91,10 +91,10 @@
 
 # Ensure protobuf C++ headers have been produced before
 # trying to compile mirclientobjects
-add_dependencies(mirclientobjects mirprotobuf)
+add_dependencies(mirclientobjects mirprotobuf mircapnproto)
 
-mir_add_library_with_symbols(mirclient SHARED ${symbol_map} $<TARGET_OBJECTS:mirclientobjects> $<TARGET_OBJECTS:mirsharedinput>)
-add_library(mirclient-static STATIC $<TARGET_OBJECTS:mirclientobjects> $<TARGET_OBJECTS:mirsharedinput>)
+mir_add_library_with_symbols(mirclient SHARED ${symbol_map} $<TARGET_OBJECTS:mirclientobjects> $<TARGET_OBJECTS:mirsharedinput> $<TARGET_OBJECTS:mirevents>)
+add_library(mirclient-static STATIC $<TARGET_OBJECTS:mirclientobjects> $<TARGET_OBJECTS:mirsharedinput> $<TARGET_OBJECTS:mirevents>)
 
 set_target_properties(mirclient
 
@@ -106,6 +106,7 @@
 set(LINKS
   mircommon
   mirprotobuf
+  mircapnproto
   mircookie
 
   ${XKBCOMMON_LIBRARIES}

=== modified file 'src/client/event.cpp'
--- src/client/event.cpp	2016-01-29 08:18:22 +0000
+++ src/client/event.cpp	2016-03-16 18:27:24 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Carr <[e-mail]>
+ *              Brandon Schaefer <[e-mail]>
  */
 
 #define MIR_LOG_COMPONENT "event-access"
@@ -32,20 +33,29 @@
 #include <cstdlib>
 #include <cstring>
 
+#include "mir_event.capnp.h"
+
 namespace ml = mir::logging;
+using Which = mir::capnp::Event::Which;
 
 namespace
 {
 template <typename EventType>
 void expect_event_type(EventType const* ev, MirEventType t)
 {
-    if (ev->type != t)
+    if (mir_event_get_type(ev) != t)
     {
         mir::log_critical("Expected " + mir::event_type_to_string(t) + " but event is of type " +
-            mir::event_type_to_string(ev->type));
+            mir::event_type_to_string(mir_event_get_type(ev)));
         abort();
     }
 }
+
+template <class T>
+MirEvent const* cast_to_mir_event(T const* t)
+{
+    return reinterpret_cast<MirEvent const*>(t);
+}
 }
 
 std::string mir::event_type_to_string(MirEventType t)
@@ -56,6 +66,8 @@
         return "mir_event_type_key";
     case mir_event_type_motion:
         return "mir_event_type_motion";
+    case mir_event_type_input:
+        return "mir_event_type_input";
     case mir_event_type_surface:
         return "mir_event_type_surface";
     case mir_event_type_resize:
@@ -66,221 +78,263 @@
         return "mir_event_type_orientation";
     case mir_event_type_close_surface:
         return "mir_event_type_close_surface";
-    case mir_event_type_input:
-        return "mir_event_type_input";
+    case mir_event_type_keymap:
+        return "mir_event_type_keymap";
+    case mir_event_type_input_configuration:
+        return "mir_event_type_input_configuration";
+    case mir_event_type_surface_output:
+        return "mir_event_type_surface_output";
     default:
         abort();
     }
 }
 
-
-MirEventType mir_event_get_type(MirEvent const* ev)
+MirEventType mir_event_get_type(MirEvent const* ev) try
 {
-    switch (ev->type)
+    switch (ev->event.asReader().which())
     {
-    case mir_event_type_key:
-    case mir_event_type_motion:
+    case Which::KEY:
+    case Which::MOTION_SET:
         return mir_event_type_input;
+    case Which::SURFACE:
+        return mir_event_type_surface;
+    case Which::RESIZE:
+        return mir_event_type_resize;
+    case Which::PROMPT_SESSION:
+        return mir_event_type_prompt_session_state_change;
+    case Which::ORIENTATION:
+        return mir_event_type_orientation;
+    case Which::CLOSE_SURFACE:
+        return mir_event_type_close_surface;
+    case Which::KEYMAP:
+        return mir_event_type_keymap;
+    case Which::INPUT_CONFIGURATION:
+        return mir_event_type_input_configuration;
+    case Which::SURFACE_OUTPUT:
+        return mir_event_type_surface_output;
     default:
-        return ev->type;
+        abort();
     }
+} catch(...)
+{
+    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)
+    auto ev_type = ev->event.asReader().which();
+    if (ev_type != Which::KEY &&
+        ev_type != Which::MOTION_SET)
     {
-        mir::log_critical("Expected input event but event is of type " +
-            mir::event_type_to_string(ev->type));
-        abort();
+            mir::log_critical("Expected input event but event is of type " +
+                mir::event_type_to_string(mir_event_get_type(ev)));
+            abort();
     }
 
     return reinterpret_cast<MirInputEvent const*>(ev);
+} catch (...) {
+    abort();
 }
 
 MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_surface);
-    
-    return &ev->surface;
+    return reinterpret_cast<MirSurfaceEvent const*>(ev);
 }
 
 MirResizeEvent const* mir_event_get_resize_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_resize);
-    
-    return &ev->resize;
+    return reinterpret_cast<MirResizeEvent const*>(ev);
 }
 
 MirPromptSessionEvent const* mir_event_get_prompt_session_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_prompt_session_state_change);
-    
-    return &ev->prompt_session;
+    return reinterpret_cast<MirPromptSessionEvent const*>(ev);
 }
 
 MirOrientationEvent const* mir_event_get_orientation_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_orientation);
-
-    return &ev->orientation;
+    return reinterpret_cast<MirOrientationEvent const*>(ev);
 }
 
 MirCloseSurfaceEvent const* mir_event_get_close_surface_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_close_surface);
-
-    return &ev->close_surface;
+    return reinterpret_cast<MirCloseSurfaceEvent const*>(ev);
 }
 
 MirKeymapEvent const* mir_event_get_keymap_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_keymap);
-
-    return &ev->keymap;
+    return reinterpret_cast<MirKeymapEvent const*>(ev);
 }
 
 MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_input_configuration);
-
-    return &ev->input_configuration;
+    return reinterpret_cast<MirInputConfigurationEvent const*>(ev);
 }
 
 MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev)
 {
     expect_event_type(ev, mir_event_type_surface_output);
-
-    return &ev->surface_output;
+    return reinterpret_cast<MirSurfaceOutputEvent const*>(ev);
 }
 
 /* Surface event accessors */
 
-MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev)
+MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* surface) try
 {
-    expect_event_type(ev, mir_event_type_surface);
-
-    return ev->attrib;
+    auto reader = (*cast_to_mir_event(surface))->asReader();
+    return static_cast<MirSurfaceAttrib>(reader.getSurface().getAttrib());
+} catch (...) {
+    abort();
 }
 
-int mir_surface_event_get_attribute_value(MirSurfaceEvent const* ev)
+int mir_surface_event_get_attribute_value(MirSurfaceEvent const* surface) try
 {
-    expect_event_type(ev, mir_event_type_surface);
-
-    return ev->value;
+    auto reader =(*cast_to_mir_event(surface))->asReader();
+    return reader.getSurface().getValue();
+} catch (...) {
+    abort();
 }
 
 /* Resize event accessors */
 
-int mir_resize_event_get_width(MirResizeEvent const* ev)
+int mir_resize_event_get_width(MirResizeEvent const* resize) try
 {
-    expect_event_type(ev, mir_event_type_resize);
-    return ev->width;
+    auto reader = (*cast_to_mir_event(resize))->asReader();
+    return reader.getResize().getWidth();
+} catch (...) {
+    abort();
 }
 
-int mir_resize_event_get_height(MirResizeEvent const* ev)
+int mir_resize_event_get_height(MirResizeEvent const* resize) try
 {
-    expect_event_type(ev, mir_event_type_resize);
-    return ev->height;
+    auto reader = (*cast_to_mir_event(resize))->asReader();
+    return reader.getResize().getHeight();
+} catch (...) {
+    abort();
 }
 
 /* Prompt session event accessors */
 
-MirPromptSessionState mir_prompt_session_event_get_state(MirPromptSessionEvent const* ev)
+MirPromptSessionState mir_prompt_session_event_get_state(MirPromptSessionEvent const* prompt) try
 {
-    expect_event_type(ev, mir_event_type_prompt_session_state_change);
-    return ev->new_state;
+    auto reader = (*cast_to_mir_event(prompt))->asReader();
+    return static_cast<MirPromptSessionState>(reader.getPromptSession().getNewState());
+} catch (...) {
+    abort();
 }
 
 /* Orientation event accessors */
 
-MirOrientation mir_orientation_event_get_direction(MirOrientationEvent const* ev)
+MirOrientation mir_orientation_event_get_direction(MirOrientationEvent const* orientation) try
 {
-    expect_event_type(ev, mir_event_type_orientation);
-    return ev->direction;
+    auto reader = (*cast_to_mir_event(orientation))->asReader();
+    return static_cast<MirOrientation>(reader.getOrientation().getDirection());
+} catch (...) {
+    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* keymap, char const** buffer, size_t* length) try
 {
-    expect_event_type(ev, mir_event_type_keymap);
+    auto reader = (*cast_to_mir_event(keymap))->asReader();
 
-    *buffer = ev->buffer;
-    *length = ev->size;
+    *buffer = reader.getKeymap().getBuffer().cStr();
+    *length = reader.getKeymap().getBuffer().size();
+} catch (...) {
+    abort();
 }
 
-MirInputDeviceId mir_keymap_event_get_device_id(MirKeymapEvent const* ev)
+MirInputDeviceId mir_keymap_event_get_device_id(MirKeymapEvent const* keymap) try
 {
-    expect_event_type(ev, mir_event_type_keymap);
-
-    return ev->device_id;
+    auto reader = (*cast_to_mir_event(keymap))->asReader();
+    return reader.getKeymap().getDeviceId().getId();
+} catch (...) {
+    abort();
 }
 
 /* Input configuration event accessors */
 
-MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->action;
-}
-
-int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->when.count();
-}
-
-MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->id;
+MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* input_config) try
+{
+    auto reader = (*cast_to_mir_event(input_config))->asReader();
+    return static_cast<MirInputConfigurationAction>(reader.getInputConfiguration().getAction());
+} catch (...) {
+    abort();
+}
+
+int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* input_config) try
+{
+    auto reader = (*cast_to_mir_event(input_config))->asReader();
+    return reader.getInputConfiguration().getWhen().getCount();
+} catch (...) {
+    abort();
+}
+
+MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* input_config) try
+{
+    auto reader = (*cast_to_mir_event(input_config))->asReader();
+    return reader.getInputConfiguration().getId().getId();
+} catch (...) {
+    abort();
 }
 
 /* Surface output event accessors */
 
-int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_surface_output);
-    return ev->dpi;
-}
-
-MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_surface_output);
-    return ev->form_factor;
-}
-
-float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev)
-{
-    expect_event_type(ev, mir_event_type_surface_output);
-    return ev->scale;
-}
-
-uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const *ev)
-{
-    expect_event_type(ev, mir_event_type_surface_output);
-    return ev->output_id;
+int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* surface_output) try
+{
+    auto reader = (*cast_to_mir_event(surface_output))->asReader();
+    return reader.getSurfaceOutput().getDpi();
+} catch (...) {
+    abort();
+}
+
+MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* surface_output) try
+{
+    auto reader = (*cast_to_mir_event(surface_output))->asReader();
+    return static_cast<MirFormFactor>(reader.getSurfaceOutput().getFormFactor());
+} catch (...) {
+    abort();
+}
+
+float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* surface_output) try
+{
+    auto reader = (*cast_to_mir_event(surface_output))->asReader();
+    return reader.getSurfaceOutput().getScale();
+} catch (...) {
+    abort();
+}
+
+uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const* surface_output) try
+{
+    auto reader = (*cast_to_mir_event(surface_output))->asReader();
+    return reader.getSurfaceOutput().getOutputId();
+} catch (...) {
+    abort();
 }
 
 // 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)
+MirEvent const* mir_event_ref(MirEvent const* ev) try
 {
     MirEvent *new_ev = new MirEvent;
-    memcpy(new_ev, ev, sizeof(MirEvent));
+    *new_ev = *ev;
 
-    if (mir_event_get_type(new_ev) == mir_event_type_keymap)
-    {
-        // malloc to match xkbcommons allocation behavior
-        auto buffer  = static_cast<char*>(malloc(new_ev->keymap.size));
-        std::memcpy(buffer, ev->keymap.buffer, new_ev->keymap.size);
-        new_ev->keymap.buffer = buffer;
-    }
     return new_ev;
+} catch (...) {
+    abort();
 }
 
-void mir_event_unref(MirEvent const* ev)
+void mir_event_unref(MirEvent const* ev) try
 {
     delete const_cast<MirEvent*>(ev);
+} catch (...) {
+    abort();
 }

=== modified file 'src/client/events/event_builders.cpp'
--- src/client/events/event_builders.cpp	2016-01-29 08:18:22 +0000
+++ src/client/events/event_builders.cpp	2016-03-16 18:27:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2015 Canonical Ltd.
+ * Copyright © 2015-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,
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Author: Robert Carr <[e-mail]>
+ *         Brandon Schaefer <[e-mail]>
  */
 
 #define MIR_LOG_COMPONENT "event-builders"
@@ -34,77 +35,71 @@
 #include <algorithm>
 #include <stdexcept>
 
+#include "mir_event.capnp.h"
+
 namespace mi = mir::input;
 namespace mf = mir::frontend;
 namespace mev = mir::events;
 namespace geom = mir::geometry;
-
-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;
-    }
-}
+namespace mcap = mir::capnp;
 
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirOrientation orientation)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_orientation;
-    e->orientation.surface_id = surface_id.as_value();
-    e->orientation.direction = orientation;
+    e->event.initOrientation();
+    auto orientation_event = e->event.getOrientation();
+
+    orientation_event.setSurfaceId(surface_id.as_value());
+    orientation_event.setDirection(orientation);
+
     return e;
 }
 
 mir::EventUPtr mev::make_event(MirPromptSessionState state)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_prompt_session_state_change;
-    e->prompt_session.new_state = state;
+    e->event.initPromptSession();
+    auto prompt_session = e->event.getPromptSession();
+
+    prompt_session.setNewState(static_cast<mcap::PromptSessionEvent::State>(state));
+
     return e;
 }
 
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, geom::Size const& size)
 {
     auto e = make_empty_event();
+    e->event.initResize();
+    auto resize = e->event.getResize();
 
-    e->type = mir_event_type_resize;
-    e->resize.surface_id = surface_id.as_value();
-    e->resize.width = size.width.as_int();
-    e->resize.height = size.height.as_int();
+    resize.setSurfaceId(surface_id.as_value());
+    resize.setWidth(size.width.as_int());
+    resize.setHeight(size.height.as_int());
+    
     return e;
 }
 
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirSurfaceAttrib attribute, int value)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_surface;
-    e->surface.id = surface_id.as_value();
-    e->surface.attrib = attribute;
-    e->surface.value = value;
+    e->event.initSurface();
+    auto surface = e->event.getSurface();
+
+    surface.setId(surface_id.as_value());
+    surface.setAttrib(static_cast<mcap::SurfaceEvent::Attrib>(attribute));
+    surface.setValue(value);
+
     return e;
 }
 
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_close_surface;
-    e->close_surface.surface_id = surface_id.as_value();
+    e->event.initCloseSurface();
+    auto close_surface = e->event.getCloseSurface();
+
+    close_surface.setSurfaceId(surface_id.as_value());
+
     return e;
 }
 
@@ -116,13 +111,14 @@
     uint32_t output_id)
 {
     auto e = make_empty_event();
+    e->event.initSurfaceOutput();
+    auto surface_output = e->event.getSurfaceOutput();
 
-    e->type = mir_event_type_surface_output;
-    e->surface_output.surface_id = surface_id.as_value();
-    e->surface_output.dpi = dpi;
-    e->surface_output.scale = scale;
-    e->surface_output.form_factor = form_factor;
-    e->surface_output.output_id = output_id;
+    surface_output.setSurfaceId(surface_id.as_value());
+    surface_output.setDpi(dpi);
+    surface_output.setScale(scale);
+    surface_output.setFormFactor(static_cast<mcap::SurfaceOutputEvent::FormFactor>(form_factor));
+    surface_output.setOutputId(output_id);
 
     return e;
 }
@@ -163,35 +159,41 @@
     int scan_code, MirInputEventModifiers modifiers)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_key;
-    auto& kev = e->key;
-    kev.device_id = device_id;
-    kev.source_id = AINPUT_SOURCE_KEYBOARD;
-    kev.event_time = timestamp;
-    kev.cookie = vector_to_cookie_as_blob(cookie);
-    kev.action = action;
-    kev.key_code = key_code;
-    kev.scan_code = scan_code;
-    kev.modifiers = modifiers;
+    e->event.initKey();
+    auto kev = e->event.getKey();
+
+    auto device = kev.getDeviceId();
+    device.setId(device_id);
+
+    auto nanoseconds = kev.getEventTime();
+    nanoseconds.setCount(timestamp.count());
+
+    ::capnp::Data::Reader cookie_data(cookie.data(), cookie.size());
+
+    kev.setSourceId(AINPUT_SOURCE_KEYBOARD);
+    kev.setCookie(cookie_data);
+    kev.setAction(static_cast<mcap::KeyboardEvent::Action>(action));
+    kev.setKeyCode(key_code);
+    kev.setScanCode(scan_code);
+    kev.setModifiers(modifiers);
 
     return e;
 }
 
-void mev::set_modifier(MirEvent& event, MirInputEventModifiers modifiers)
+void mev::set_modifier(MirEvent& e, MirInputEventModifiers modifiers)
 {
-    switch(event.type)
+    switch(e->which())
     {
-    case mir_event_type_key:
+    case mcap::Event::Which::KEY:
         {
-            auto& kev = event.key;
-            kev.modifiers = modifiers;
+            auto kev = e->getKey();
+            kev.setModifiers(modifiers);
             break;
         }
-    case mir_event_type_motion:
+    case mcap::Event::Which::MOTION_SET:
         {
-            auto& mev = event.motion;
-            mev.modifiers = modifiers;
+            auto mev = e->getMotionSet();
+            mev.setModifiers(modifiers);
             break;
         }
     default:
@@ -199,25 +201,44 @@
     }
 }
 
-void mev::set_cursor_position(MirEvent& event, mir::geometry::Point const& pos)
-{
-    if (event.type != mir_event_type_motion &&
-        event.motion.source_id != AINPUT_SOURCE_MOUSE &&
-        event.motion.pointer_count == 1)
-        BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor position is only valid for pointer events."));
-
-    event.motion.pointer_coordinates[0].x = pos.x.as_float();
-    event.motion.pointer_coordinates[0].y = pos.y.as_float();
-}
-
-void mev::set_button_state(MirEvent& event, MirPointerButtons button_state)
-{
-    if (event.type != mir_event_type_motion &&
-        event.motion.source_id != AINPUT_SOURCE_MOUSE &&
-        event.motion.pointer_count == 1)
-        BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor position is only valid for pointer events."));
-
-    event.motion.buttons = button_state;
+namespace
+{
+bool event_is_pointer_event(MirEvent& e)
+{
+    if (e->which() != mcap::Event::Which::MOTION_SET)
+    {
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor position is only valid for pointer events."));
+    }
+
+    auto mev = e->getMotionSet();
+    if (mev.getSourceId() != AINPUT_SOURCE_MOUSE &&
+        mev.getMotions().size() == 1)
+    {
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor position is only valid for pointer events."));
+    }
+
+    return true;
+}
+}
+
+void mev::set_cursor_position(MirEvent& e, mir::geometry::Point const& pos)
+{
+    if (event_is_pointer_event(e))
+    {
+        auto mev = e->getMotionSet();
+        auto pointerCoord = mev.getMotions();
+        pointerCoord[0].setX(pos.x.as_float());
+        pointerCoord[0].setY(pos.y.as_float());
+    }
+}
+
+void mev::set_button_state(MirEvent& e, MirPointerButtons button_state)
+{
+    if (event_is_pointer_event(e))
+    {
+        auto mev = e->getMotionSet();
+        mev.setButtons(button_state);
+    }
 }
 
 // Deprecated version with uint64_t mac
@@ -240,14 +261,21 @@
     std::vector<uint8_t> const& cookie, MirInputEventModifiers modifiers)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_motion;
-    auto& mev = e->motion;
-    mev.device_id = device_id;
-    mev.event_time = timestamp;
-    mev.cookie = vector_to_cookie_as_blob(cookie);
-    mev.modifiers = modifiers;
-    mev.source_id = AINPUT_SOURCE_TOUCHSCREEN;
+    e->event.initMotionSet();
+    auto mev = e->event.getMotionSet();
+
+    auto device = mev.getDeviceId();
+    device.setId(device_id);
+
+    auto nanoseconds = mev.getEventTime();
+    nanoseconds.setCount(timestamp.count());
+
+    ::capnp::Data::Reader cookie_data(cookie.data(), cookie.size());
+
+    mev.setCookie(cookie_data);
+    mev.setModifiers(modifiers);
+    mev.setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+    mev.initMotions(mcap::MotionEventSet::MAX_COUNT);
 
     return e;
 }
@@ -270,17 +298,19 @@
     MirTouchTooltype tooltype, float x_axis_value, float y_axis_value,
     float pressure_value, float touch_major_value, float touch_minor_value, float size_value)
 {
-    auto& mev = event.motion;
-    auto& pc = mev.pointer_coordinates[mev.pointer_count++];
-    pc.id = touch_id;
-    pc.tool_type = tooltype;
-    pc.x = x_axis_value;
-    pc.y = y_axis_value;
-    pc.pressure = pressure_value;
-    pc.touch_major = touch_major_value;
-    pc.touch_minor = touch_minor_value;
-    pc.size = size_value;
-    pc.action = action;
+    auto mev = event->getMotionSet();
+    auto pointer_count = mev.getCount();
+    auto pc = mev.getMotions()[pointer_count];
+    pc.setId(touch_id);
+    pc.setToolType(static_cast<mcap::MotionEventSet::Motion::ToolType>(tooltype));
+    pc.setX(x_axis_value);
+    pc.setY(y_axis_value);
+    pc.setPressure(pressure_value);
+    pc.setTouchMajor(touch_major_value);
+    pc.setTouchMinor(touch_minor_value);
+    pc.setSize(size_value);
+    pc.setAction(action);
+    mev.setCount(pointer_count + 1);
 }
 
 mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
@@ -291,25 +321,32 @@
     float relative_x_value, float relative_y_value)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_motion;
-    auto& mev = e->motion;
-    mev.device_id = device_id;
-    mev.event_time = timestamp;
-    mev.cookie = vector_to_cookie_as_blob(cookie);
-    mev.modifiers = modifiers;
-    mev.source_id = AINPUT_SOURCE_MOUSE;
-    mev.buttons = buttons_pressed;
-
-    mev.pointer_count = 1;
-    auto& pc = mev.pointer_coordinates[0];
-    mev.pointer_coordinates[0].action = action;
-    pc.x = x_axis_value;
-    pc.y = y_axis_value;
-    pc.dx = relative_x_value;
-    pc.dy = relative_y_value;
-    pc.hscroll = hscroll_value;
-    pc.vscroll = vscroll_value;
+    e->event.initMotionSet();
+    auto mev = e->event.getMotionSet();
+
+    auto device = mev.getDeviceId();
+    device.setId(device_id);
+
+    auto nanoseconds = mev.getEventTime();
+    nanoseconds.setCount(timestamp.count());
+
+    ::capnp::Data::Reader cookie_data(cookie.data(), cookie.size());
+
+    mev.setCookie(cookie_data);
+    mev.setModifiers(modifiers);
+    mev.setSourceId(AINPUT_SOURCE_MOUSE);
+    mev.setButtons(buttons_pressed);
+
+    mev.setCount(1);
+    mev.initMotions(1);
+    auto pc = mev.getMotions()[0];
+    pc.setAction(action);
+    pc.setX(x_axis_value);
+    pc.setY(y_axis_value);
+    pc.setDx(relative_x_value);
+    pc.setDy(relative_y_value);
+    pc.setHscroll(hscroll_value);
+    pc.setVscroll(vscroll_value);
 
     return e;
 }
@@ -366,6 +403,8 @@
                                std::string const& layout, std::string const& variant, std::string const& options)
 {
     auto e = make_empty_event();
+    e->event.initKeymap();
+    auto keymap = e->event.getKeymap();
 
     auto ctx = mi::make_unique_context();
     auto map = mi::make_unique_keymap(ctx.get(), model, layout, variant, options);
@@ -373,12 +412,17 @@
     if (!map.get())
         BOOST_THROW_EXCEPTION(std::runtime_error("failed to assemble keymap from given parameters"));
 
-    e->type = mir_event_type_keymap;
-    e->keymap.surface_id = surface_id.as_value();
-    e->keymap.device_id = id;
+    auto device = keymap.getDeviceId();
+    device.setId(id);
+
+    keymap.setSurfaceId(surface_id.as_value());
+
     // TODO consider caching compiled keymaps
-    e->keymap.buffer = xkb_keymap_get_as_string(map.get(), XKB_KEYMAP_FORMAT_TEXT_V1);
-    e->keymap.size = strlen(e->keymap.buffer);
+    char* keymap_as_string = xkb_keymap_get_as_string(map.get(), XKB_KEYMAP_FORMAT_TEXT_V1);
+    ::capnp::Text::Reader buffer_text(keymap_as_string);
+
+    keymap.setBuffer(buffer_text);
+    std::free(keymap_as_string);
 
     return e;
 }
@@ -386,11 +430,16 @@
 mir::EventUPtr mev::make_event(MirInputConfigurationAction action, MirInputDeviceId id, std::chrono::nanoseconds time)
 {
     auto e = make_empty_event();
-
-    e->type = mir_event_type_input_configuration;
-    e->input_configuration.action = action;
-    e->input_configuration.when = time;
-    e->input_configuration.id = id;
+    e->event.initInputConfiguration();
+    auto input_configuration = e->event.getInputConfiguration();
+
+    auto device = input_configuration.getId();
+    device.setId(id);
+
+    auto nanoseconds = input_configuration.getWhen();
+    nanoseconds.setCount(time.count());
+
+    input_configuration.setAction(static_cast<mcap::InputConfigurationEvent::Action>(action));
 
     return e;
 }

=== modified file 'src/client/events/make_empty_event.cpp'
--- src/client/events/make_empty_event.cpp	2016-01-22 16:40:15 +0000
+++ src/client/events/make_empty_event.cpp	2016-03-16 18:27:24 +0000
@@ -19,24 +19,16 @@
 #include "make_empty_event.h"
 #include "mir/events/event_private.h"
 
+#include <capnp/message.h>
+
 #include <cstring>
 #include <cstdlib>
 
 namespace mev = mir::events;
-namespace
-{
-    void delete_event(MirEvent *e)
-    {
-        // xkbcommon creates the keymap through malloc
-        if (e && e->type == mir_event_type_keymap)
-            std::free(const_cast<char*>(e->keymap.buffer));
-        delete e;
-    }
-}
 
 mir::EventUPtr mev::make_empty_event()
 {
-    auto e = new MirEvent;
-    std::memset(e, 0, sizeof (MirEvent));
-    return mir::EventUPtr(e, delete_event);
+    auto e = new MirEvent();
+
+    return mir::EventUPtr(e, [](MirEvent* e) { delete e; });
 }

=== modified file 'src/client/events/serialization.cpp'
--- src/client/events/serialization.cpp	2016-01-22 16:40:15 +0000
+++ src/client/events/serialization.cpp	2016-03-16 18:27:24 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Andreas Pokorny <[e-mail]>
+ *              Brandon Schaefer <[e-mail]>
  */
 
 #include "make_empty_event.h"
@@ -23,89 +24,32 @@
 #include <boost/throw_exception.hpp>
 #include <cstring>
 
+#include <capnp/serialize.h>
+
 namespace mev = mir::events;
 
-namespace
-{
-template<typename Data>
-char const* consume(char const* pos, Data& data)
-{
-    std::memcpy(&data, pos, sizeof data);
-    return pos + sizeof data;
-}
-
-template<typename Data>
-void encode(std::string& encoded, Data const& data)
-{
-    encoded.append(reinterpret_cast<char const*>(&data), sizeof data);
-}
-}
-
 std::string mev::serialize_event(MirEvent const& event)
 {
-    auto type = mir_event_get_type(&event);
+    std::string output;
+    auto event_segments = const_cast<MirEvent&>(event).message.getSegmentsForOutput();
+    auto flat_event = ::capnp::messageToFlatArray(event_segments);
 
-    switch (type)
+    for (auto const& c : flat_event.asBytes())
     {
-    case mir_event_type_keymap:
-        {
-            std::string encoded;
-            auto const& keymap = event.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;
-        }
-    default:
-        return {reinterpret_cast<char const*>(&event), sizeof event};
+        output += c;
     }
+
+    return output;
 }
 
 mir::EventUPtr mev::deserialize_event(std::string const& raw)
 {
-    auto ev = make_empty_event();
-    auto& event = *ev;
-    auto minimal_event_size = sizeof event.type;
-    auto const stream_size = raw.size();
-    if (stream_size < minimal_event_size)
-        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
-
-    char const* pos = consume(raw.data(), event.type);
-
-    switch (event.type)
-    {
-    case mir_event_type_keymap:
-    {
-        auto& keymap = event.keymap;
-        minimal_event_size += sizeof keymap.surface_id + sizeof keymap.device_id + sizeof keymap.size;
-
-        if (stream_size < minimal_event_size)
-            BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
-        pos = consume(pos, keymap.surface_id);
-        pos = consume(pos, keymap.device_id);
-        pos = consume(pos, keymap.size);
-
-        minimal_event_size += keymap.size;
-
-        if (stream_size < minimal_event_size)
-            BOOST_THROW_EXCEPTION(std::runtime_error("Failed to deserialize event"));
-
-        auto buffer  = static_cast<char*>(malloc(keymap.size));
-        std::memcpy(buffer, pos, keymap.size);
-        keymap.buffer = buffer;
-        break;
-    }
-    default:
-        consume(raw.data(), event);
-        break;
-    }
-
-    return ev;
+    auto e = mev::make_empty_event();
+    kj::ArrayPtr<::capnp::word const> words(reinterpret_cast<::capnp::word const*>(
+        raw.data()), raw.size() / sizeof(::capnp::word));
+
+    initMessageBuilderFromFlatArrayCopy(words, e->message);
+    e->event = e->message.getRoot<mir::capnp::Event>();
+
+    return e;
 }

=== modified file 'src/client/input/CMakeLists.txt'
--- src/client/input/CMakeLists.txt	2016-01-29 08:18:22 +0000
+++ src/client/input/CMakeLists.txt	2016-03-16 18:27:24 +0000
@@ -30,6 +30,8 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/xkb_mapper.cpp
 )
 
+add_dependencies(mirsharedinput mircapnproto)
+
 list(APPEND MIR_CLIENT_REFERENCES ${XKBCOMMON_LIBRARIES})
 
 set(MIR_CLIENT_SOURCES ${MIR_CLIENT_SOURCES} PARENT_SCOPE)

=== modified file 'src/client/input/android/android_input_lexicon.cpp'
--- src/client/input/android/android_input_lexicon.cpp	2016-01-29 08:18:22 +0000
+++ src/client/input/android/android_input_lexicon.cpp	2016-03-16 18:27:24 +0000
@@ -84,7 +84,7 @@
                     mev::add_touch(*ev, mev->getPointerId(i), action, mia::mir_tool_type_from_android(mev->getToolType(i)),
                         mev->getX(i), mev->getY(i),
                         mev->getPressure(i), mev->getTouchMajor(i),
-			mev->getTouchMinor(i), mev->getSize(i));
+                        mev->getTouchMinor(i), mev->getSize(i));
                 }
                 return ev;
             }

=== modified file 'src/client/input/android/event_conversion_helpers.cpp'
--- src/client/input/android/event_conversion_helpers.cpp	2016-03-16 06:59:01 +0000
+++ src/client/input/android/event_conversion_helpers.cpp	2016-03-16 18:27:24 +0000
@@ -201,11 +201,12 @@
 int32_t mia::extract_masked_android_action_from(MirEvent const& ev)
 {
     int index_with_action = -1;
-    auto const& mev = ev.motion;
+    auto mev = ev.event.asReader().getMotionSet();
+    auto pointer_count = mev.getCount();
 
-    for (unsigned i = 0; i < mev.pointer_count; i++)
+    for (unsigned i = 0; i < pointer_count; i++)
     {
-        if (mev.pointer_coordinates[i].action == mir_touch_action_change)
+        if (mev.getMotions()[i].getAction() == mir_touch_action_change)
             continue;
         index_with_action = i;
     }
@@ -213,16 +214,16 @@
         return AMOTION_EVENT_ACTION_MOVE;
     
     int masked_action = AMOTION_EVENT_ACTION_MASK;
-    switch (mev.pointer_coordinates[index_with_action].action)
+    switch (mev.getMotions()[index_with_action].getAction())
     {
     case mir_touch_action_up:
-        if (mev.pointer_count != 1)
+        if (pointer_count != 1)
             masked_action &= AMOTION_EVENT_ACTION_POINTER_UP;
         else
             masked_action &= AMOTION_EVENT_ACTION_UP;
         break;
     case mir_touch_action_down:
-        if (mev.pointer_count != 1)
+        if (pointer_count != 1)
             masked_action &= AMOTION_EVENT_ACTION_POINTER_DOWN;
         else
             masked_action &= AMOTION_EVENT_ACTION_DOWN;
@@ -275,10 +276,13 @@
 
 int32_t mia::extract_android_action_from(MirEvent const& event)
 {
-    if (mia::android_source_id_is_pointer_device(event.motion.source_id))
+    auto mev = event->asReader().getMotionSet();
+    if (mia::android_source_id_is_pointer_device(mev.getSourceId()))
     {
         return mia::android_pointer_action_from_mir(
-            static_cast<MirPointerAction>(event.motion.pointer_coordinates[0].action), event.motion.buttons);
+            static_cast<MirPointerAction>(
+            mev.getMotions()[0].getAction()),
+            mev.getButtons());
     }
     else
     {

=== modified file 'src/client/input/input_event.cpp'
--- src/client/input/input_event.cpp	2016-03-16 06:59:01 +0000
+++ src/client/input/input_event.cpp	2016-03-16 18:27:24 +0000
@@ -14,41 +14,35 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Carr <[e-mail]>
+ *              Brandon Schaefer <[e-mail]>
  */
 
 #define MIR_LOG_COMPONENT "input-event-access"
 
+#include "mir/event_type_to_string.h"
 #include "mir/cookie/cookie.h"
-#include "mir/event_type_to_string.h"
 #include "mir/events/event_private.h"
+#include "mir/mir_cookie.h"
 #include "mir/log.h"
 #include "mir/require.h"
 #include "mir_toolkit/mir_cookie.h"
 
-#include "../mir_cookie.h"
 
 #include <string.h>
 
 namespace ml = mir::logging;
+using Which = mir::capnp::Event::Which;
 
 namespace
 {
-void expect_old_event_type(MirEvent const* ev, MirEventType t)
-{
-    if (ev->type != t)
-    {
-        mir::log_critical("Expected " + mir::event_type_to_string(t) + " but event is of type " +
-            mir::event_type_to_string(ev->type));
-        abort();
-    }
-}
-
-std::string input_event_type_to_string(MirInputEventType input_event_type)
-{
-    switch (input_event_type)
+std::string input_event_type_to_string(MirInputEventType t)
+{
+    switch (t)
     {
         case mir_input_event_type_key:
             return "mir_input_event_type_key";
+        case mir_input_event_type_pointer:
+            return "mir_input_event_type_pointer";
         case mir_input_event_type_touch:
             return "mir_input_event_type_touch";
         default:
@@ -56,6 +50,16 @@
     }
 }
 
+void expect_input_event_type(MirInputEvent const* iev, MirInputEventType t)
+{
+    if (mir_input_event_get_type(iev) != t)
+    {
+        mir::log_critical("Expected " + input_event_type_to_string(t) + " but event is of type " +
+            input_event_type_to_string(mir_input_event_get_type(iev)));
+        abort();
+    }
+}
+
 // Never exposed in old event, so lets avoid leaking it in to a header now.
 enum 
 {
@@ -84,25 +88,6 @@
     AINPUT_SOURCE_ANY = 0xffffff00
 };
 
-MirEvent const* old_ev_from_new(MirInputEvent const* ev)
-{
-    return reinterpret_cast<MirEvent const*>(ev);
-}
-
-MirMotionEvent const& old_mev_from_new(MirTouchEvent const* ev)
-{
-    auto old_ev = reinterpret_cast<MirEvent const*>(ev);
-    expect_old_event_type(old_ev, mir_event_type_motion);
-    return old_ev->motion;
-}
-
-MirMotionEvent const& old_mev_from_new(MirPointerEvent const* ev)
-{
-    auto old_ev = reinterpret_cast<MirEvent const*>(ev);
-    expect_old_event_type(old_ev, mir_event_type_motion);
-    return old_ev->motion;
-}
-
 // Differentiate between MirTouchEvents and MirPointerEvents based on old device class
 MirInputEventType type_from_device_class(int32_t source_class)
 {
@@ -118,210 +103,197 @@
         return mir_input_event_type_touch;
     }
 }
-}
-
-MirInputEventType mir_input_event_get_type(MirInputEvent const* ev)
-{
-    auto old_ev = old_ev_from_new(ev);
-    
-    if (old_ev->type != mir_event_type_key && old_ev->type != mir_event_type_motion)
-    {
-        mir::log_critical("expected input event but event was of type " + mir::event_type_to_string(old_ev->type));
-        abort();
-    }
-
-    switch (old_ev->type)
-    {
-    case mir_event_type_key:
-        return mir_input_event_type_key;
-    case mir_event_type_motion:
-        return type_from_device_class(old_ev->motion.source_id);
-    default:
-        abort();
-    }
-}
-
-MirInputDeviceId mir_input_event_get_device_id(MirInputEvent const* ev)
-{
-    auto old_ev = old_ev_from_new(ev);
-
-    if(mir_event_get_type(old_ev) != mir_event_type_input)
-    {
-        mir::log_critical("expected input event but event was of type " + mir::event_type_to_string(old_ev->type));
-        abort();
-    }
-
-    switch (old_ev->type)
-    {
-    case mir_event_type_motion:
-        return old_ev->motion.device_id;
-    case mir_event_type_key:
-        return old_ev->key.device_id;
-    default:
-        abort();
-    }
-}
-
-int64_t mir_input_event_get_event_time(MirInputEvent const* ev)
-{
-    auto old_ev = old_ev_from_new(ev);
-    if(mir_event_get_type(old_ev) != mir_event_type_input)
-    {
-        mir::log_critical("expected input event but event was of type " + mir::event_type_to_string(old_ev->type));
-        abort();
-    }
-
-    switch (old_ev->type)
-    {
-    case mir_event_type_motion:
-        return old_ev->motion.event_time.count();
-    case mir_event_type_key:
-        return old_ev->key.event_time.count();
-    default:
-        abort();
-    }
-}
-
-MirInputEvent const* mir_pointer_event_input_event(MirPointerEvent const* event)
-{
-    return reinterpret_cast<MirInputEvent const*>(event);
-}
-
-MirInputEvent const* mir_keyboard_event_input_event(MirKeyboardEvent const* event)
-{
-    return reinterpret_cast<MirInputEvent const*>(event);
-}
-
-MirInputEvent const* mir_touch_event_input_event(MirTouchEvent const* event)
-{
-    return reinterpret_cast<MirInputEvent const*>(event);
+
+template <class T>
+MirEvent const* cast_to_mir_event(T const* t)
+{
+    return reinterpret_cast<MirEvent const*>(t);
+}
+}
+
+MirInputEventType mir_input_event_get_type(MirInputEvent const* iev) try
+{
+    auto reader = (*iev)->asReader();
+    switch (reader.which())
+    {
+        case Which::KEY:
+          return mir_input_event_type_key;
+        case Which::MOTION_SET:
+          return type_from_device_class(reader.getMotionSet().getSourceId());   
+        default:
+            abort();
+    }
+} catch (...)
+{
+    abort();
+}
+
+MirInputDeviceId mir_input_event_get_device_id(MirInputEvent const* iev) try
+{
+    auto reader = (*iev)->asReader();
+    switch (reader.which())
+    {
+        case Which::KEY:
+          return reader.getKey().getDeviceId().getId();
+        case Which::MOTION_SET:
+          return reader.getMotionSet().getDeviceId().getId();
+        default:
+            abort();
+    }
+} catch (...)
+{
+    abort();
+}
+
+int64_t mir_input_event_get_event_time(MirInputEvent const* iev) try
+{
+    auto reader = (*iev)->asReader();
+    switch (reader.which())
+    {
+        case Which::KEY:
+          return reader.getKey().getEventTime().getCount();
+        case Which::MOTION_SET:
+          return reader.getMotionSet().getEventTime().getCount();
+        default:
+            abort();
+    }
+} catch (...)
+{
+    abort();
+}
+
+MirInputEvent const* mir_pointer_event_input_event(MirPointerEvent const* pev)
+{
+    expect_input_event_type(pev, mir_input_event_type_pointer);
+    return pev;
+}
+
+MirInputEvent const* mir_keyboard_event_input_event(MirKeyboardEvent const* kev)
+{
+    expect_input_event_type(kev, mir_input_event_type_key);
+    return kev;
+}
+
+MirInputEvent const* mir_touch_event_input_event(MirTouchEvent const* tev)
+{
+    expect_input_event_type(tev, mir_input_event_type_touch);
+    return tev;
 }
 
 /* Key event accessors */
 
-MirKeyboardEvent const* mir_input_event_get_keyboard_event(MirInputEvent const* ev)
+MirKeyboardEvent const* mir_input_event_get_keyboard_event(MirInputEvent const* iev)
 {
-    if (mir_input_event_get_type(ev) != mir_input_event_type_key)
-    {
-        mir::log_critical("expected key input event but event was of type " +
-            input_event_type_to_string(mir_input_event_get_type(ev)));
-        abort();
-    }
-    
-    return reinterpret_cast<MirKeyboardEvent const*>(ev);
+    return reinterpret_cast<MirKeyboardEvent const*>(iev);
 }
 
 MirKeyboardAction mir_keyboard_event_action(MirKeyboardEvent const* kev)
 {
-    return kev->action;
+    auto reader = (*cast_to_mir_event(kev))->asReader();
+    return static_cast<MirKeyboardAction>(reader.getKey().getAction());
 }
 
 xkb_keysym_t mir_keyboard_event_key_code(MirKeyboardEvent const* kev)
 {
-    return kev->key_code;
+    auto reader = (*cast_to_mir_event(kev))->asReader();
+    return reader.getKey().getKeyCode();
 }
 
 int mir_keyboard_event_scan_code(MirKeyboardEvent const* kev)
 {
-    return kev->scan_code;
+    auto reader = (*cast_to_mir_event(kev))->asReader();
+    return reader.getKey().getScanCode();
 }
 
 MirInputEventModifiers mir_keyboard_event_modifiers(MirKeyboardEvent const* kev)
 {    
-    return kev->modifiers;
+
+    auto reader = (*cast_to_mir_event(kev))->asReader();
+    return reader.getKey().getModifiers();
 }
 /* Touch event accessors */
 
-MirInputEventModifiers mir_touch_event_modifiers(MirTouchEvent const* tev)
+MirInputEventModifiers mir_touch_event_modifiers(MirTouchEvent const* mev)
 {    
-    auto const& old_mev = old_mev_from_new(tev);
-    return old_mev.modifiers;
+    auto reader = (*cast_to_mir_event(mev))->asReader();
+    return reader.getMotionSet().getModifiers();
 }
 
 MirTouchEvent const* mir_input_event_get_touch_event(MirInputEvent const* ev)
 {
-    if(mir_input_event_get_type(ev) != mir_input_event_type_touch)
-    {
-        mir::log_critical("expected touch input event but event was of type " +
-            input_event_type_to_string(mir_input_event_get_type(ev)));
-        abort();
-    }
-
     return reinterpret_cast<MirTouchEvent const*>(ev);
 }
 
-unsigned int mir_touch_event_point_count(MirTouchEvent const* event)
-{
-    auto const& old_mev = reinterpret_cast<MirEvent const*>(event)->motion;
-    return old_mev.pointer_count;
-}
-
-MirTouchId mir_touch_event_id(MirTouchEvent const* event, size_t touch_index)
-{
-    auto const& old_mev = old_mev_from_new(event);
-
-    if (touch_index >= old_mev.pointer_count)
-    {
-        mir::log_critical("touch index is greater than pointer count");
-        abort();
-    }
-
-    return old_mev.pointer_coordinates[touch_index].id;
-}
-
-MirTouchAction mir_touch_event_action(MirTouchEvent const* event, size_t touch_index)
-{
-    auto const& old_mev = old_mev_from_new(event);
-
-    if(touch_index > old_mev.pointer_count)
-    {
-        mir::log_critical("touch index is greater than pointer count");
-        abort();
-    }
-    
-    return static_cast<MirTouchAction>(old_mev.pointer_coordinates[touch_index].action);
-}
-
-MirTouchTooltype mir_touch_event_tooltype(MirTouchEvent const* event,
-    size_t touch_index)
-{
-    auto const& old_mev = old_mev_from_new(event);
-
-    if(touch_index > old_mev.pointer_count)
-    {
-        mir::log_critical("touch index is greater than pointer count");
-        abort();
-    }
-
-    return old_mev.pointer_coordinates[touch_index].tool_type;
-}
-
-float mir_touch_event_axis_value(MirTouchEvent const* event,
+unsigned int mir_touch_event_point_count(MirTouchEvent const* tev)
+{
+    auto reader = (*cast_to_mir_event(tev))->asReader();
+    return reader.getMotionSet().getCount();
+}
+
+MirTouchId mir_touch_event_id(MirTouchEvent const* tev, size_t touch_index)
+{
+    auto reader = (*cast_to_mir_event(tev))->asReader();
+    if (touch_index >= reader.getMotionSet().getCount())
+    {
+        mir::log_critical("touch index is greater than pointer count");
+        abort();
+    }
+
+    return reader.getMotionSet().getMotions()[touch_index].getId();
+}
+
+MirTouchAction mir_touch_event_action(MirTouchEvent const* tev, size_t touch_index)
+{
+    auto reader = (*cast_to_mir_event(tev))->asReader();
+    if (touch_index >= reader.getMotionSet().getCount())
+    {
+        mir::log_critical("touch index is greater than pointer count");
+        abort();
+    }
+
+    auto action = reader.getMotionSet().getMotions()[touch_index].getAction();
+    return static_cast<MirTouchAction>(action);
+}
+
+MirTouchTooltype mir_touch_event_tooltype(MirTouchEvent const* tev, size_t touch_index)
+{
+    auto reader = (*cast_to_mir_event(tev))->asReader();
+    if (touch_index >= reader.getMotionSet().getCount())
+    {
+        mir::log_critical("touch index is greater than pointer count");
+        abort();
+    }
+
+    auto tool_type = reader.getMotionSet().getMotions()[touch_index].getToolType();
+    return static_cast<MirTouchTooltype>(tool_type);
+}
+
+float mir_touch_event_axis_value(MirTouchEvent const* tev,
     size_t touch_index, MirTouchAxis axis)
 {
-    auto const& old_mev = old_mev_from_new(event);
-
-    if(touch_index > old_mev.pointer_count)
+    auto reader = (*cast_to_mir_event(tev))->asReader();
+    if (touch_index >= reader.getMotionSet().getCount())
     {
         mir::log_critical("touch index is greater than pointer count");
         abort();
     }
 
-    auto const& old_pc = old_mev.pointer_coordinates[touch_index];
+    auto const& pc = reader.getMotionSet().getMotions()[touch_index];
+
     switch (axis)
     {
     case mir_touch_axis_x:
-        return old_pc.x;
+        return pc.getX();
     case mir_touch_axis_y:
-        return old_pc.y;
+        return pc.getY();
     case mir_touch_axis_pressure:
-        return old_pc.pressure;
+        return pc.getPressure();
     case mir_touch_axis_touch_major:
-        return old_pc.touch_major;
+        return pc.getTouchMajor();
     case mir_touch_axis_touch_minor:
-        return old_pc.touch_minor;
+        return pc.getTouchMinor();
     case mir_touch_axis_size:
-        return old_pc.size;
+        return pc.getSize();
     default:
         return -1;
     }
@@ -331,80 +303,78 @@
 
 MirPointerEvent const* mir_input_event_get_pointer_event(MirInputEvent const* ev)
 {
-    if(mir_input_event_get_type(ev) != mir_input_event_type_pointer)
-    {
-        mir::log_critical("expected pointer input event but event was of type " +
-            input_event_type_to_string(mir_input_event_get_type(ev)));
-        abort();
-    }
-
     return reinterpret_cast<MirPointerEvent const*>(ev);
 }
 
 MirInputEventModifiers mir_pointer_event_modifiers(MirPointerEvent const* pev)
 {    
-    auto const& old_mev = old_mev_from_new(pev);
-    return old_mev.modifiers;
+    auto reader = (*cast_to_mir_event(pev))->asReader();
+    return reader.getMotionSet().getModifiers();
 }
 
 MirPointerAction mir_pointer_event_action(MirPointerEvent const* pev)
 {    
-    auto const& old_mev = old_mev_from_new(pev);
-    return static_cast<MirPointerAction>(old_mev.pointer_coordinates[0].action);
+    auto reader = (*cast_to_mir_event(pev))->asReader();
+    auto action = reader.getMotionSet().getMotions()[0].getAction();
+    return static_cast<MirPointerAction>(action);
 }
 
 bool mir_pointer_event_button_state(MirPointerEvent const* pev,
     MirPointerButton button)
 {
-   auto const& old_mev = old_mev_from_new(pev);
-   return old_mev.buttons & button;
+    auto reader = (*cast_to_mir_event(pev))->asReader();
+    auto mev = reader.getMotionSet();
+
+    return mev.getButtons() & button;
 }
 
 MirPointerButtons mir_pointer_event_buttons(MirPointerEvent const* pev)
 {
-   auto const& old_mev = old_mev_from_new(pev);
-   return old_mev.buttons;
+    auto reader = (*cast_to_mir_event(pev))->asReader();
+    return reader.getMotionSet().getButtons();
 }
 
 float mir_pointer_event_axis_value(MirPointerEvent const* pev, MirPointerAxis axis)
 {
-   auto const& old_mev = old_mev_from_new(pev);
-   switch (axis)
-   {
-   case mir_pointer_axis_x:
-       return old_mev.pointer_coordinates[0].x;
-   case mir_pointer_axis_y:
-       return old_mev.pointer_coordinates[0].y;
-   case mir_pointer_axis_relative_x:
-       return old_mev.pointer_coordinates[0].dx;
-   case mir_pointer_axis_relative_y:
-       return old_mev.pointer_coordinates[0].dy;
-   case mir_pointer_axis_vscroll:
-       return old_mev.pointer_coordinates[0].vscroll;
-   case mir_pointer_axis_hscroll:
-       return old_mev.pointer_coordinates[0].hscroll;
-   default:
+    auto reader = (*cast_to_mir_event(pev))->asReader();
+    auto const& coord = reader.getMotionSet().getMotions()[0];
+
+    switch (axis)
+    {
+    case mir_pointer_axis_x:
+       return coord.getX();
+    case mir_pointer_axis_y:
+       return coord.getY();
+    case mir_pointer_axis_relative_x:
+       return coord.getDx();
+    case mir_pointer_axis_relative_y:
+       return coord.getDy();
+    case mir_pointer_axis_vscroll:
+       return coord.getVscroll();
+    case mir_pointer_axis_hscroll:
+       return coord.getHscroll();
+    default:
        mir::log_critical("Invalid axis enumeration " + std::to_string(axis));
        abort();
-   }
+    }
 }
 
-bool mir_input_event_has_cookie(MirInputEvent const* ev)
+bool mir_input_event_has_cookie(MirInputEvent const* iev)
 {
-    switch (mir_input_event_get_type(ev))
+    switch (mir_input_event_get_type(iev))
     {
         case mir_input_event_type_key:
             return true;
         case mir_input_event_type_pointer:
         {
-            auto const pev = mir_input_event_get_pointer_event(ev);
+            auto const pev = mir_input_event_get_pointer_event(iev);
             auto const pev_action = mir_pointer_event_action(pev);
             return (pev_action == mir_pointer_action_button_up ||
                     pev_action == mir_pointer_action_button_down);
         }
         case mir_input_event_type_touch:
         {
-            auto const tev = mir_input_event_get_touch_event(ev);
+            auto const tev = mir_input_event_get_touch_event(iev);
             auto const point_count = mir_touch_event_point_count(tev);
             for (size_t i = 0; i < point_count; i++)
             {
@@ -432,17 +402,30 @@
 
 MirCookie const* mir_input_event_get_cookie(MirInputEvent const* iev) try
 {
-    auto const ev = old_ev_from_new(iev);
-
-    switch (ev->type)
-    {
-    case mir_event_type_motion:
-        return new MirCookie(ev->motion.cookie);
-    case mir_event_type_key:
-        return new MirCookie(ev->key.cookie);
+    auto reader = (*iev)->asReader();
+
+    switch (reader.which())
+    {
+    case Which::KEY:
+    {
+        auto cookie = reader.getKey().getCookie();
+        std::vector<uint8_t> cookie_data(cookie.size());
+        std::copy(std::begin(cookie), std::end(cookie), std::begin(cookie_data));
+
+        return new MirCookie(cookie_data);
+    }
+    case Which::MOTION_SET:
+    {
+        auto cookie = reader.getMotionSet().getCookie();
+        std::vector<uint8_t> cookie_data(cookie.size());
+        std::copy(std::begin(cookie), std::end(cookie), std::begin(cookie_data));
+
+        return new MirCookie(cookie_data);
+    }
     default:
     {
-        mir::log_critical("expected a key or motion events, type was: " + mir::event_type_to_string(ev->type));
+        mir::log_critical("expected a key or motion events, type was: " +
+            mir::event_type_to_string(mir_event_get_type(iev)));
         abort();
     }
     }

=== modified file 'src/client/input/xkb_mapper.cpp'
--- src/client/input/xkb_mapper.cpp	2016-01-29 08:18:22 +0000
+++ src/client/input/xkb_mapper.cpp	2016-03-16 18:27:24 +0000
@@ -77,7 +77,6 @@
 
 namespace
 {
-
 static uint32_t to_xkb_scan_code(uint32_t evdev_scan_code)
 {
     // xkb scancodes are offset by 8 from evdev scancodes for compatibility with X protocol.
@@ -96,30 +95,29 @@
 
     return XKB_KEY_NoSymbol;
 }
-
 }
 
-void mircv::XKBMapper::update_state_and_map_event(MirEvent& ev)
+void mircv::XKBMapper::update_state_and_map_event(MirEvent& event)
 {
     std::lock_guard<std::mutex> lg(guard);
 
-    auto& key_ev = ev.key;
+    auto key_ev = event->getKey();
 
     xkb_key_direction direction = XKB_KEY_DOWN;
 
     bool update_state = true;
-    if (key_ev.action == mir_keyboard_action_up)
+    if (key_ev.getAction() == mir::capnp::KeyboardEvent::Action::UP)
         direction = XKB_KEY_UP;
-    else if (key_ev.action == mir_keyboard_action_down)
+    else if (key_ev.getAction() == mir::capnp::KeyboardEvent::Action::DOWN)
         direction = XKB_KEY_DOWN;
-    else if (key_ev.action == mir_keyboard_action_repeat)
+    else if (key_ev.getAction() == mir::capnp::KeyboardEvent::Action::REPEAT)
         update_state = false;
 
-    uint32_t xkb_scan_code = to_xkb_scan_code(key_ev.scan_code);
+    uint32_t xkb_scan_code = to_xkb_scan_code(key_ev.getScanCode());
     if (update_state)
         xkb_state_update_key(state.get(), xkb_scan_code, direction);
 
-    key_ev.key_code = keysym_for_scan_code(state.get(), xkb_scan_code);
+    key_ev.setKeyCode(keysym_for_scan_code(state.get(), xkb_scan_code));
 }
 
 // id should be used in the future to implement per device keymaps

=== 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-03-16 18:27:24 +0000
@@ -16,34 +16,35 @@
  * Authored by: Brandon Schaefer <[e-mail]>
  */
 
-#include "mir_cookie.h"
+#include "mir/mir_cookie.h"
 
 #include "mir/require.h"
 
 #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_surface.cpp'
--- src/client/mir_surface.cpp	2016-03-14 10:13:49 +0000
+++ src/client/mir_surface.cpp	2016-03-16 18:27:24 +0000
@@ -28,9 +28,9 @@
 #include "mir/client_buffer.h"
 #include "mir/dispatch/threaded_dispatcher.h"
 #include "mir/input/input_platform.h"
+#include "mir/mir_cookie.h"
 #include "mir/input/xkb_mapper.h"
 #include "mir/cookie/cookie.h"
-#include "mir_cookie.h"
 
 #include <cassert>
 #include <unistd.h>
@@ -495,7 +495,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/rpc/mir_protobuf_rpc_channel.cpp'
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2016-03-16 06:59:01 +0000
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2016-03-16 18:27:24 +0000
@@ -27,7 +27,6 @@
 #include "../make_protobuf_object.h"
 #include "mir/input/input_devices.h"
 #include "mir/variable_length_array.h"
-#include "mir/events/event_builders.h"
 #include "mir/events/event_private.h"
 #include "mir/events/serialization.h"
 
@@ -340,34 +339,38 @@
                     auto const send_e = [&e](MirSurface* surface)
                         { surface->handle_event(*e); };
 
-                    switch (e->type)
+                    auto reader = e->event.asReader();
+
+                    switch (e->event.asReader().which())
                     {
-                    case mir_event_type_surface:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->surface.id), send_e);
-                        break;
-
-                    case mir_event_type_resize:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->resize.surface_id), send_e);
-                        break;
-
-                    case mir_event_type_orientation:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->orientation.surface_id), send_e);
-                        break;
-
-                    case mir_event_type_close_surface:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->close_surface.surface_id), send_e);
-                        break;
-                    case mir_event_type_keymap:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->keymap.surface_id), send_e);
-                        break;
-                    case mir_event_type_surface_output:
-                        if (auto map = surface_map.lock())
-                            map->with_surface_do(mf::SurfaceId(e->surface_output.surface_id), send_e);
+                    case mir::capnp::Event::Which::SURFACE:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getSurface().getId()), send_e);
+                        break;
+
+                    case mir::capnp::Event::Which::RESIZE:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getResize().getSurfaceId()), send_e);
+                        break;
+
+                    case mir::capnp::Event::Which::ORIENTATION:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getOrientation().getSurfaceId()), send_e);
+                        break;
+
+                    case mir::capnp::Event::Which::CLOSE_SURFACE:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getCloseSurface().getSurfaceId()), send_e);
+                        break;
+
+                    case mir::capnp::Event::Which::KEYMAP:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getKeymap().getSurfaceId()), send_e);
+                        break;
+
+                    case mir::capnp::Event::Which::SURFACE_OUTPUT:
+                        if (auto map = surface_map.lock())
+                            map->with_surface_do(mf::SurfaceId(reader.getSurfaceOutput().getSurfaceId()), send_e);
                         break;
                     default:
                         event_sink->handle_event(*e);

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2016-03-16 06:59:01 +0000
+++ src/client/symbols.map	2016-03-16 18:27:24 +0000
@@ -326,6 +326,15 @@
     };
 } MIR_CLIENT_DETAIL_9v18;
 
+MIR_CLIENT_DETAIL_unreleased {
+  global:
+    extern "C++" { 
+      mir::event_type_to_string*;
+    };
+  local:
+    *;
+} MIR_CLIENT_DETAIL_9v19;
+
 MIR_CLIENT_DETAIL_private_buffer_semantics {
   global:
     mir_buffer_get_fence;

=== modified file 'src/common/CMakeLists.txt'
--- src/common/CMakeLists.txt	2016-01-29 08:18:22 +0000
+++ src/common/CMakeLists.txt	2016-03-16 18:27:24 +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)
 
@@ -9,6 +8,7 @@
 add_subdirectory(logging)
 add_subdirectory(report/lttng)
 add_subdirectory(env)
+add_subdirectory(events)
 add_subdirectory(sharedlibrary)
 add_subdirectory(thread)
 add_subdirectory(time)

=== added directory 'src/common/events'
=== added file 'src/common/events/CMakeLists.txt'
--- src/common/events/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/common/events/CMakeLists.txt	2016-03-16 18:27:24 +0000
@@ -0,0 +1,38 @@
+# 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/>.
+#
+# Authored by: Brandon Schaefer <[e-mail]>
+
+set(EVENT_SOURCES
+  capnp_enums_aligned_asserts.cpp
+  event_private.cpp
+)
+
+set(
+  MIR_GENERATED_INCLUDE_DIRECTORIES
+  ${MIR_GENERATED_INCLUDE_DIRECTORIES}
+  PARENT_SCOPE)
+
+add_library(
+  mirevents OBJECT
+  ${EVENT_SOURCES}
+)
+
+add_dependencies(mirevents mircapnproto)
+
+include_directories(
+    ${PROJECT_SOURCE_DIR}/include/client
+    ${PROJECT_SOURCE_DIR}/src/include/cookie
+    ${MIR_GENERATED_INCLUDE_DIRECTORIES}
+)

=== added file 'src/common/events/capnp_enums_aligned_asserts.cpp'
--- src/common/events/capnp_enums_aligned_asserts.cpp	1970-01-01 00:00:00 +0000
+++ src/common/events/capnp_enums_aligned_asserts.cpp	2016-03-16 18:27:24 +0000
@@ -0,0 +1,82 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Brandon Schaefer <[e-mail]>
+ */
+
+#include "mir/events/event_private.h"
+#include "mir_event.capnp.h"
+
+namespace mcap = mir::capnp;
+
+/* Static asserts that our capnp enums are equal to the c api enums.
+   This way we can tell on compile time if any of the enums are incorrect.
+*/
+namespace
+{
+static_assert(static_cast<MirKeyboardAction>(mcap::KeyboardEvent::Action::UP) ==
+    mir_keyboard_action_up, "");
+static_assert(static_cast<MirKeyboardAction>(mcap::KeyboardEvent::Action::DOWN) ==
+    mir_keyboard_action_down, "");
+static_assert(static_cast<MirKeyboardAction>(mcap::KeyboardEvent::Action::REPEAT) ==
+    mir_keyboard_action_repeat, "");
+
+static_assert(static_cast<MirTouchTooltype>(mcap::MotionEventSet::Motion::ToolType::UNKNOWN) ==
+    mir_touch_tooltype_unknown, "");
+static_assert(static_cast<MirTouchTooltype>(mcap::MotionEventSet::Motion::ToolType::FINGER) ==
+    mir_touch_tooltype_finger, "");
+static_assert(static_cast<MirTouchTooltype>(mcap::MotionEventSet::Motion::ToolType::STYLUS) ==
+    mir_touch_tooltype_stylus, "");
+
+static_assert(static_cast<MirInputConfigurationAction>(mcap::InputConfigurationEvent::Action::CONFIGURATION_CHANGED) ==
+    mir_input_configuration_action_configuration_changed, "");
+static_assert(static_cast<MirInputConfigurationAction>(mcap::InputConfigurationEvent::Action::DEVICE_RESET) ==
+    mir_input_configuration_action_device_reset, "");
+
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::TYPE) ==
+    mir_surface_attrib_type, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::STATE) ==
+    mir_surface_attrib_state, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::SWAP_INTERVAL) ==
+    mir_surface_attrib_swapinterval, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::FOCUS) ==
+    mir_surface_attrib_focus, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::DPI) ==
+    mir_surface_attrib_dpi, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::VISIBILITY) ==
+    mir_surface_attrib_visibility, "");
+static_assert(static_cast<MirSurfaceAttrib>(mcap::SurfaceEvent::Attrib::PREFERRED_ORIENTATION) ==
+    mir_surface_attrib_preferred_orientation, "");
+
+static_assert(static_cast<MirPromptSessionState>(mcap::PromptSessionEvent::State::STOPPED) ==
+    mir_prompt_session_state_stopped, "");
+static_assert(static_cast<MirPromptSessionState>(mcap::PromptSessionEvent::State::STARTED) ==
+    mir_prompt_session_state_started, "");
+static_assert(static_cast<MirPromptSessionState>(mcap::PromptSessionEvent::State::SUSPENDED) ==
+    mir_prompt_session_state_suspended, "");
+
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::UNKNOWN) ==
+    mir_form_factor_unknown, "");
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::PHONE) ==
+    mir_form_factor_phone, "");
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::TABLET) ==
+    mir_form_factor_tablet, "");
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::MONITOR) ==
+    mir_form_factor_monitor, "");
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::TV) ==
+    mir_form_factor_tv, "");
+static_assert(static_cast<MirFormFactor>(mcap::SurfaceOutputEvent::FormFactor::PROJECTOR) ==
+    mir_form_factor_projector, "");
+}

=== added file 'src/common/events/event_private.cpp'
--- src/common/events/event_private.cpp	1970-01-01 00:00:00 +0000
+++ src/common/events/event_private.cpp	2016-03-16 18:27:24 +0000
@@ -0,0 +1,67 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Brandon Schaefer <[e-mail]>
+ */
+
+#include "mir/events/event_private.h"
+
+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;
+}
+
+// Deep copy from a reader
+MirEvent::MirEvent(mir::capnp::Event::Reader& reader)
+{
+    message.setRoot(reader);
+    event = message.getRoot<mir::capnp::Event>();
+}
+
+MirEvent::MirEvent(::capnp::Data::Reader& reader)
+{
+    message.setRoot(reader);
+    event = message.getRoot<mir::capnp::Event>();
+}
+
+mir::capnp::Event::Builder& MirEvent::operator*()
+{
+    return event;
+}
+
+mir::capnp::Event::Builder const& MirEvent::operator*() const
+{
+    return event;
+}
+
+mir::capnp::Event::Builder* MirEvent::operator->()
+{
+    return &event;
+}
+
+mir::capnp::Event::Builder const* MirEvent::operator->() const
+{
+    return &event;
+}

=== renamed file 'src/client/mir_cookie.h' => 'src/include/client/mir/mir_cookie.h'
--- src/client/mir_cookie.h	2016-01-22 20:16:50 +0000
+++ src/include/client/mir/mir_cookie.h	2016-03-16 18:27:24 +0000
@@ -22,19 +22,21 @@
 
 #include "mir/cookie/blob.h"
 
+#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/include/common/mir/events/event_private.h'
--- src/include/common/mir/events/event_private.h	2016-01-29 08:18:22 +0000
+++ src/include/common/mir/events/event_private.h	2016-03-16 18:27:24 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voss <[e-mail]>
+ *              Brandon Schaefer <[e-mail]>
  */
 
 // ==================================
@@ -35,167 +36,42 @@
 #include <array>
 #include <chrono>
 
-#ifdef __cplusplus
-/**
- * \addtogroup mir_toolkit
- * @{
- */
-extern "C" {
-#endif
-/* TODO: To the moon. */
-#define MIR_INPUT_EVENT_MAX_POINTER_COUNT 16
-
-// PRIVATE
-// Direct access to MirKeyboardEvent is deprecated. Please use mir_event_get_input_event
-// and the mir_input_event* family of functions.
-struct MirKeyboardEvent
-{
-    MirEventType type;
-
-    int32_t device_id;
-    int32_t source_id;
-    MirKeyboardAction action;
-    MirInputEventModifiers modifiers;
-
-    int32_t key_code;
-    int32_t scan_code;
-
-    std::chrono::nanoseconds event_time;
-    mir::cookie::Blob cookie;
-};
-
-typedef struct
-{
-    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;
-} MirMotionPointer;
-
-// PRIVATE
-// Direct access to MirMotionEvent is deprecated. Please use mir_event_get_input_event
-// and the mir_input_event* family of functions.
-typedef struct
-{
-    MirEventType type;
-
-    int32_t device_id;
-    int32_t source_id;
-
-    MirInputEventModifiers modifiers;
-
-    MirPointerButtons buttons;
-    std::chrono::nanoseconds event_time;
-    mir::cookie::Blob cookie;
-
-    size_t pointer_count;
-    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 */
-} MirMotionEvent;
- 
-struct MirInputConfigurationEvent
-{
-    MirEventType type;
-
-    MirInputConfigurationAction action;
-    std::chrono::nanoseconds when;
-    MirInputDeviceId id;
-};
-
-struct MirSurfaceEvent
-{
-    MirEventType type;
-
-    int id;
-    MirSurfaceAttrib attrib;
-    int value;
-};
-
-struct MirResizeEvent
-{
-    MirEventType type;
-
-    int surface_id;
-    int width;
-    int height;
-};
-
-struct MirPromptSessionEvent
-{
-    MirEventType type;
-
-    MirPromptSessionState new_state;
-};
-
-struct MirOrientationEvent
-{
-    MirEventType type;
-
-    int surface_id;
-    MirOrientation direction;
-};
-
-struct MirCloseSurfaceEvent
-{
-    MirEventType type;
-
-    int surface_id;
-};
-
-struct MirKeymapEvent
-{
-    MirEventType type;
-
-    int surface_id;
-    MirInputDeviceId device_id;
-    char const* buffer;
-    size_t size;
-};
-
-struct MirSurfaceOutputEvent
-{
-    MirEventType type;
-
-    int surface_id;
-    int dpi;
-    float scale;
-    MirFormFactor form_factor;
-    uint32_t output_id;
-};
-
-// Access to MirEvent is deprecated
-union MirEvent
-{
-    MirEventType     type;
-    MirKeyboardEvent key;
-    MirMotionEvent   motion;
-    MirSurfaceEvent  surface;
-    MirResizeEvent   resize;
-    MirPromptSessionEvent  prompt_session;
-    MirOrientationEvent orientation;
-    MirCloseSurfaceEvent   close_surface;
-    MirKeymapEvent keymap;
-    MirInputConfigurationEvent input_configuration;
-    MirSurfaceOutputEvent surface_output;
-};
-
-#ifdef __cplusplus
-}
-/**@}*/
-#endif
+#include <capnp/message.h>
+#include "mir_event.capnp.h"
+
+struct MirEvent
+{
+    MirEvent() = default;
+    MirEvent(MirEvent const& e);
+    MirEvent& operator=(MirEvent const& e);
+
+    // Deep copy from a reader
+    explicit MirEvent(mir::capnp::Event::Reader& reader);
+    explicit MirEvent(::capnp::Data::Reader& reader);
+
+    mir::capnp::Event::Builder& operator*();
+    mir::capnp::Event::Builder const& operator*() const;
+
+    mir::capnp::Event::Builder* operator->();
+    mir::capnp::Event::Builder const* operator->() const;
+
+    ::capnp::MallocMessageBuilder message;
+    mir::capnp::Event::Builder event{message.initRoot<mir::capnp::Event>()};
+};
+
+// Helper for implicit upcast to a MirEvent
+struct MirSurfaceEvent            : MirEvent { };
+struct MirResizeEvent             : MirEvent { };
+struct MirPromptSessionEvent      : MirEvent { };
+struct MirOrientationEvent        : MirEvent { };
+struct MirCloseSurfaceEvent       : MirEvent { };
+struct MirKeymapEvent             : MirEvent { };
+struct MirInputConfigurationEvent : MirEvent { };
+struct MirSurfaceOutputEvent      : MirEvent { };
+struct MirInputEvent              : MirEvent { };
+struct MirKeyboardEvent           : MirInputEvent { };
+struct MirMotionEvent             : MirInputEvent { };
+struct MirPointerEvent            : MirMotionEvent { };
+struct MirTouchEvent              : MirMotionEvent { };
 
 #endif /* MIR_COMMON_EVENT_PRIVATE_H_ */

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2016-03-16 06:59:01 +0000
+++ src/server/CMakeLists.txt	2016-03-16 18:27:24 +0000
@@ -64,6 +64,7 @@
   $<TARGET_OBJECTS:mirserverobjects>
   $<TARGET_OBJECTS:mirinput>
   $<TARGET_OBJECTS:mirscene>
+  $<TARGET_OBJECTS:mirevents>
   $<TARGET_OBJECTS:mircompositor>
   $<TARGET_OBJECTS:mirgraphics>
   $<TARGET_OBJECTS:mirfrontend>
@@ -102,6 +103,7 @@
   mirplatform
   mircommon
   mirprotobuf
+  mircapnproto
   mircookie
 
   ${GLog_LIBRARY}

=== modified file 'src/server/graphics/nested/display_buffer.cpp'
--- src/server/graphics/nested/display_buffer.cpp	2016-01-29 08:18:22 +0000
+++ src/server/graphics/nested/display_buffer.cpp	2016-03-16 18:27:24 +0000
@@ -109,19 +109,21 @@
     if (mir_event_get_type(&event) != mir_event_type_input)
         return;
 
-    if (event.type == mir_event_type_motion)
+    if (event->asReader().which() == mir::capnp::Event::Which::MOTION_SET)
     {
         auto my_event = event;
         auto iev = mir_event_get_input_event(&my_event);
 
         if (mir_input_event_get_type(iev) == mir_input_event_type_pointer)
         {
-            auto& motion = my_event.motion;
+            auto motion = my_event->getMotionSet();
 
-            for (size_t i = 0; i != motion.pointer_count; ++i)
+            for (size_t i = 0; i != motion.getCount(); ++i)
             {
-                motion.pointer_coordinates[i].x += area.top_left.x.as_float();
-                motion.pointer_coordinates[i].y += area.top_left.y.as_float();
+                auto x = motion.getMotions()[i].getX();
+                auto y = motion.getMotions()[i].getY();
+                motion.getMotions()[i].setX(x + area.top_left.x.as_float());
+                motion.getMotions()[i].setY(y + area.top_left.y.as_float());
             }
 
             auto pev = mir_input_event_get_pointer_event(iev);

=== modified file 'src/server/input/android/input_sender.cpp'
--- src/server/input/android/input_sender.cpp	2016-03-16 06:59:01 +0000
+++ src/server/input/android/input_sender.cpp	2016-03-16 18:27:24 +0000
@@ -230,6 +230,22 @@
             });
 }
 
+namespace
+{
+mir::cookie::Blob convert_capnp_cookie_to_blob(::capnp::Data::Reader 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;
+}
+}
+
 droidinput::status_t mia::InputSender::ActiveTransfer::send_key_event(uint32_t seq, MirEvent const& event)
 {
     int32_t repeat_count = 0;
@@ -247,7 +263,7 @@
                                      mir_keyboard_event_scan_code(key_event),
                                      mia::android_modifiers_from_mir(mir_keyboard_event_modifiers(key_event)),
                                      repeat_count,
-                                     event.key.cookie,
+                                     convert_capnp_cookie_to_blob(event->asReader().getKey().getCookie()),
                                      event_time,
                                      event_time);
 }
@@ -255,10 +271,11 @@
 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::MotionEventSet::MAX_COUNT];
+    droidinput::PointerProperties properties[mir::capnp::MotionEventSet::MAX_COUNT];
     auto input_event = mir_event_get_input_event(&event);
     auto touch = mir_input_event_get_touch_event(input_event);
+    auto cookie = convert_capnp_cookie_to_blob(event->asReader().getMotionSet().getCookie());
     std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
     auto const x_offset = 0.0f;
     auto const y_offset = 0.0f;
@@ -324,7 +341,7 @@
         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.motion.cookie,
+                                           button_state, x_offset, y_offset, x_precision, y_precision, cookie,
                                            event_time, event_time, contacts_in_event, properties, coords);
     }
 
@@ -349,6 +366,8 @@
     pointer_properties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE;
     pointer_properties.id = 0;
 
+    auto cookie = convert_capnp_cookie_to_blob(event->asReader().getMotionSet().getCookie());
+
     std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
     auto const x_offset = 0.0f;
     auto const y_offset = 0.0f;
@@ -361,7 +380,7 @@
         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.motion.cookie, event_time, event_time, 1, &pointer_properties, &pointer_coord);
+        y_precision, 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-01-29 08:18:22 +0000
+++ src/server/input/default_event_builder.cpp	2016-03-16 18:27:24 +0000
@@ -53,9 +53,10 @@
 {
     if (action == mir_touch_action_up || action == mir_touch_action_down)
     {
-        auto const cookie = cookie_authority->make_cookie(event.motion.event_time.count());
+        auto const cookie = cookie_authority->make_cookie(event->getMotionSet().getEventTime().getCount());
         auto const serialized_cookie = cookie->serialize();
-        std::copy_n(std::begin(serialized_cookie), event.motion.cookie.size(), std::begin(event.motion.cookie));
+        ::capnp::Data::Reader cookie_data(serialized_cookie.data(), serialized_cookie.size());
+        event->getMotionSet().setCookie(cookie_data);
     }
 
     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-03-16 06:59:01 +0000
+++ src/server/input/key_repeat_dispatcher.cpp	2016-03-16 18:27:24 +0000
@@ -114,16 +114,6 @@
     return next_dispatcher->dispatch(event);
 }
 
-namespace
-{
-MirEvent copy_to_repeat_ev(MirKeyboardEvent const* kev)
-{
-    MirEvent repeat_ev(*reinterpret_cast<MirEvent const*>(kev));
-    repeat_ev.key.action = mir_keyboard_action_repeat;
-    return repeat_ev;
-}
-}
-
 // Returns true if the original event has been handled, that is ::dispatch should not pass it on.
 bool mi::KeyRepeatDispatcher::handle_key_input(MirInputDeviceId id, MirKeyboardEvent const* kev)
 {
@@ -146,7 +136,9 @@
     }
     case mir_keyboard_action_down:
     {
-        MirEvent ev = copy_to_repeat_ev(kev);
+        auto reader = reinterpret_cast<MirEvent const*>(kev)->event.asReader();
+        MirEvent ev(reader);
+        ev->getKey().setAction(static_cast<mir::capnp::KeyboardEvent::Action>(mir_keyboard_action_repeat));
 
         auto it = device_state.repeat_alarms_by_scancode.find(scan_code);
         if (it != device_state.repeat_alarms_by_scancode.end())
@@ -160,10 +152,14 @@
             {
                 std::lock_guard<std::mutex> lg(repeat_state_mutex);
 
-                ev.key.event_time = std::chrono::steady_clock::now().time_since_epoch();
-                auto const cookie = cookie_authority->make_cookie(ev.key.event_time.count());
+                auto event_time = ev->getKey().getEventTime();
+                event_time.setCount(std::chrono::steady_clock::now().time_since_epoch().count());
+
+                auto const cookie = cookie_authority->make_cookie(event_time.getCount());
                 auto const serialized_cookie = cookie->serialize();
-                std::copy_n(std::begin(serialized_cookie), ev.key.cookie.size(), std::begin(ev.key.cookie));
+                ::capnp::Data::Reader cookie_data(serialized_cookie.data(), serialized_cookie.size());
+                ev->getKey().setCookie(cookie_data);
+
                 next_dispatcher->dispatch(ev);
 
                 capture_alarm->reschedule_in(repeat_delay);

=== modified file 'src/server/input/surface_input_dispatcher.cpp'
--- src/server/input/surface_input_dispatcher.cpp	2016-01-29 08:18:22 +0000
+++ src/server/input/surface_input_dispatcher.cpp	2016-03-16 18:27:24 +0000
@@ -76,15 +76,18 @@
     MirEvent to_deliver;
     to_deliver = *reinterpret_cast<MirEvent const*>(ev);
     
-    if (to_deliver.type == mir_event_type_motion)
+    if (to_deliver->which() == mir::capnp::Event::Which::MOTION_SET)
     {
         auto sx = surface->input_bounds().top_left.x.as_int();
         auto sy = surface->input_bounds().top_left.y.as_int();
+        auto mev = to_deliver->getMotionSet();
 
-        for (unsigned i = 0; i < to_deliver.motion.pointer_count; i++)
+        for (unsigned i = 0; i < mev.getCount(); i++)
         {
-            to_deliver.motion.pointer_coordinates[i].x -= sx;
-            to_deliver.motion.pointer_coordinates[i].y -= sy;
+            auto x = mev.getMotions()[i].getX();
+            auto y = mev.getMotions()[i].getY();
+            mev.getMotions()[i].setX(x - sx);
+            mev.getMotions()[i].setY(y - sy);
         }
     }
     surface->consume(&to_deliver);

=== modified file 'src/server/input/validator.cpp'
--- src/server/input/validator.cpp	2016-01-29 08:18:22 +0000
+++ src/server/input/validator.cpp	2016-03-16 18:27:24 +0000
@@ -50,8 +50,6 @@
     }
     auto tev = mir_input_event_get_touch_event(iev);
     handle_touch_event(mir_input_event_get_device_id(iev), tev);
-
-    return;
 }
 
 namespace
@@ -64,63 +62,66 @@
 
 mir::EventUPtr copy_event(MirTouchEvent const* ev)
 {
-    MirEvent *ret = new MirEvent;
-    memcpy(ret, ev, sizeof(MirEvent));
+    auto reader = reinterpret_cast<MirEvent const*>(ev)->event.asReader();
+    MirEvent* ret = new MirEvent(reader);
     return make_event_uptr(ret);
 }
 
 // Return a copy of ev with existing touch actions converted to change.
 // Note this is always a valid successor of ev in the event stream.
-mir::EventUPtr convert_touch_actions_to_change(MirTouchEvent const* ev)
+mir::EventUPtr convert_touch_actions_to_change(MirTouchEvent const* tev)
 {
-    auto ret = copy_event(ev);
+    auto ret = copy_event(tev);
+    auto mev = (*ret)->getMotionSet();
 
-    for (size_t i = 0; i < ret->motion.pointer_count; i++)
+    for (size_t i = 0; i < mev.getCount(); i++)
     {
-        ret->motion.pointer_coordinates[i].action = mir_touch_action_change;
+        mev.getMotions()[i].setAction(mir_touch_action_change);
     }
     return ret;
 }
 
 // Helper function to find index for a given touch ID
 // TODO: Existence of this probably suggests a problem with TouchEvent API...
-int index_for_id(MirTouchEvent const* touch_ev, MirTouchId id)
+int index_for_id(MirTouchEvent const* tev, MirTouchId id)
 {
-    MirEvent const* ev = reinterpret_cast<MirEvent const*>(touch_ev);
-    for (size_t i = 0; i < ev->motion.pointer_count; i++)
+    MirEvent const* ev = reinterpret_cast<MirEvent const*>(tev);
+    auto mev = (*ev)->asReader().getMotionSet();
+
+    for (size_t i = 0; i < mev.getCount(); i++)
     {
-        if (ev->motion.pointer_coordinates[i].id == id)
+        if (mev.getMotions()[i].getId() == id)
             return i;
     }
     return -1;
 }
 
 // Return an event which is a valid successor of valid_ev but contains a mir_touch_action_down for missing_id
-mir::EventUPtr add_missing_down(MirEvent const* valid_ev, MirTouchEvent const* ev, MirTouchId missing_id)
+mir::EventUPtr add_missing_down(MirEvent const* valid_ev, MirTouchEvent const* tev, MirTouchId missing_id)
 {
     auto valid_tev = reinterpret_cast<MirTouchEvent const*>(valid_ev);
     
     // So as not to repeat already occurred actions, we copy the last valid (Delivered) event and replace all the actions
     // with change, then we will add a missing down for touch "missing_id"
     auto ret = convert_touch_actions_to_change(valid_tev);
-    auto index = index_for_id(ev, missing_id);
+    auto index = index_for_id(tev, missing_id);
 
     // In the case where a touch ID goes up and then reappears without a down we don't want to
     // add a new touch but merely replace the action in the last event.
     if (auto existing_index = index_for_id((MirTouchEvent const*)ret.get(), missing_id) >= 0)
     {
-        ret->motion.pointer_coordinates[existing_index].action = mir_touch_action_down;
+        (*ret)->getMotionSet().getMotions()[existing_index].setAction(mir_touch_action_down);
     }
     else
     {
         mev::add_touch(*ret, missing_id, mir_touch_action_down,
-            mir_touch_event_tooltype(ev, index),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_x),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_y),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_pressure),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_touch_major),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_touch_minor),
-            mir_touch_event_axis_value(ev, index, mir_touch_axis_size));
+            mir_touch_event_tooltype(tev, index),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_x),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_y),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_pressure),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_touch_major),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_touch_minor),
+            mir_touch_event_axis_value(tev, index, mir_touch_axis_size));
     }
     
   return ret;
@@ -136,7 +137,7 @@
     auto ret = convert_touch_actions_to_change(tev);
     auto index = index_for_id(tev, missing_an_up_id);
 
-    ret->motion.pointer_coordinates[index].action = mir_touch_action_up;
+    (*ret)->getMotionSet().getMotions()[index].setAction(mir_touch_action_up);
 
     return ret;
 }
@@ -147,7 +148,7 @@
 {
     auto tev = reinterpret_cast<MirTouchEvent const*>(ev);
     auto ret = copy_event(tev);
-    ret->motion.pointer_count = 0;
+    (*ret)->getMotionSet().setCount(0);
     
     for (size_t i = 0; i < mir_touch_event_point_count(tev); i++)
     {
@@ -190,53 +191,52 @@
 // things are fine. On the other hand if they show up with mir_touch_action_change then a touch point
 // has appeared before its gone down and thus we must inject an event signifying this touch going down.
 void mi::Validator::ensure_stream_validity_locked(std::lock_guard<std::mutex> const&,
-    MirTouchEvent const* ev, MirTouchEvent const* last_ev)
+    MirTouchEvent const* tev, MirTouchEvent const* last_tev)
 {
     TouchSet expected;
-    for (size_t i = 0; i < mir_touch_event_point_count(last_ev); i++)
+    for (size_t i = 0; i < mir_touch_event_point_count(last_tev); i++)
     {
-        auto action = mir_touch_event_action(last_ev, i);
+        auto action = mir_touch_event_action(last_tev, i);
         if (action == mir_touch_action_up)
             continue;
-        expected.insert(mir_touch_event_id(last_ev, i));
+        expected.insert(mir_touch_event_id(last_tev, i));
     }
 
     TouchSet found;
-    for (size_t i = 0; i < mir_touch_event_point_count(ev); i++)
+    for (size_t i = 0; i < mir_touch_event_point_count(tev); i++)
     {
-        auto id = mir_touch_event_id(ev, i);
+        auto id = mir_touch_event_id(tev, i);
         found.insert(id);
     }
 
     // Insert missing touch releases
-    auto last_ev_copy =
-        remove_old_releases_from(reinterpret_cast<MirEvent const*>(last_ev));
+    auto last_tev_copy =
+        remove_old_releases_from(reinterpret_cast<MirEvent const*>(last_tev));
     for (auto const& expected_id : expected)
     {
         if (found.find(expected_id) == found.end())
         {
-            auto inject_ev = add_missing_up(last_ev_copy.get(), expected_id);
+            auto inject_ev = add_missing_up(last_tev_copy.get(), expected_id);
             dispatch_valid_event(*inject_ev);
-            last_ev_copy = remove_old_releases_from(inject_ev.get());
+            last_tev_copy = remove_old_releases_from(inject_ev.get());
         }
     }
 
-    for (size_t i = 0; i < mir_touch_event_point_count(ev); i++)
+    for (size_t i = 0; i < mir_touch_event_point_count(tev); i++)
     {
-        auto id = mir_touch_event_id(ev, i);
+        auto id = mir_touch_event_id(tev, i);
         if (expected.find(id) == expected.end() &&
-            mir_touch_event_action(ev, i) != mir_touch_action_down)
+            mir_touch_event_action(tev, i) != mir_touch_action_down)
         {
-            
-            auto inject_ev = add_missing_down(last_ev_copy.get(), ev, id);
+            auto inject_ev = add_missing_down(last_tev_copy.get(), tev, id);
             dispatch_valid_event(*inject_ev);
-            last_ev_copy = std::move(inject_ev);
+            last_tev_copy = std::move(inject_ev);
         }
     }
 }
 
 
-void mi::Validator::handle_touch_event(MirInputDeviceId id, MirTouchEvent const* ev)
+void mi::Validator::handle_touch_event(MirInputDeviceId id, MirTouchEvent const* tev)
 {
     std::lock_guard<std::mutex> lg(state_guard);
 
@@ -244,12 +244,12 @@
     MirTouchEvent const* last_ev = nullptr;
     auto default_ev = mev::make_event(id,
         std::chrono::high_resolution_clock::now().time_since_epoch(),
-        std::vector<uint8_t>{}, /* No need for a mac, since there's no pointer count for a default event */
+        std::vector<uint8_t>{}, // No need for a mac, since there's no pointer count for a default event
         mir_input_event_modifier_none); 
 
     if (it == last_event_by_device.end())
     {
-        last_event_by_device.insert(std::make_pair(id, copy_event(ev)));
+        last_event_by_device.insert(std::make_pair(id, copy_event(tev)));
         last_ev = reinterpret_cast<MirTouchEvent const*>(default_ev.get());
     }
     else
@@ -257,12 +257,12 @@
         last_ev = mir_input_event_get_touch_event(mir_event_get_input_event(it->second.get()));
     }
     
-    ensure_stream_validity_locked(lg, ev, last_ev);
+    ensure_stream_validity_locked(lg, tev, last_ev);
 
     // Seems to be no better way to replace a non default constructible value type in an unordered_map
     // C++17 will give us insert_or_assign
     last_event_by_device.erase(id);
-    last_event_by_device.insert(std::make_pair(id, copy_event(ev)));
+    last_event_by_device.insert(std::make_pair(id, copy_event(tev)));
     
-    dispatch_valid_event(*reinterpret_cast<MirEvent const*>(ev));
+    dispatch_valid_event(*reinterpret_cast<MirEvent const*>(tev));
 }

=== modified file 'tests/unit-tests/client/input/test_android_input_receiver.cpp'
--- tests/unit-tests/client/input/test_android_input_receiver.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2016-03-16 18:27:24 +0000
@@ -131,10 +131,6 @@
 {
 public:
     AndroidInputReceiverSetup()
-        : event_handler{[this](MirEvent* ev)
-                        {
-                            last_event = *ev;
-                        }}
     {
         auto status = droidinput::InputChannel::openInputFdPair(server_fd, client_fd);
         EXPECT_EQ(droidinput::OK, status);
@@ -154,8 +150,7 @@
     int server_fd, client_fd;
 
     static std::chrono::milliseconds const next_event_timeout;
-    MirEvent last_event;
-    std::function<void(MirEvent*)> event_handler;
+    std::function<void(MirEvent*)> event_handler{[this](MirEvent*) {}};
 };
 
 std::chrono::milliseconds const AndroidInputReceiverSetup::next_event_timeout(1000);
@@ -163,9 +158,13 @@
 
 TEST_F(AndroidInputReceiverSetup, receiver_receives_key_events)
 {
+    MirEvent last_event;
     mircva::InputReceiver receiver{client_fd,
                                    std::make_shared<mircv::XKBMapper>(),
-                                   event_handler,
+                                   [&last_event](MirEvent* ev)
+                                   {
+                                       last_event = *ev;
+                                   },
                                    std::make_shared<mircv::NullInputReceiverReport>()};
     TestingInputProducer producer{server_fd};
 
@@ -176,8 +175,8 @@
     EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), next_event_timeout));
     receiver.dispatch(md::FdEvent::readable);
 
-    EXPECT_EQ(mir_event_type_key, last_event.type);
-    EXPECT_EQ(producer.testing_key_event_scan_code, last_event.key.scan_code);
+    EXPECT_EQ(mir::capnp::Event::Which::KEY, last_event.event.which());
+    EXPECT_EQ(producer.testing_key_event_scan_code, last_event.event.getKey().getScanCode());
 }
 
 TEST_F(AndroidInputReceiverSetup, receiver_handles_events)
@@ -257,7 +256,7 @@
     EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), next_event_timeout));
     receiver.dispatch(md::FdEvent::readable);
     EXPECT_TRUE(handler_called);
-    ASSERT_EQ(mir_event_type_key, ev.type);
+    ASSERT_EQ(mir::capnp::Event::Which::KEY, ev->which());
 
     // The motion is still too new. Won't be reported yet, but is batched.
     auto start = high_resolution_clock::now();
@@ -284,7 +283,7 @@
     receiver.dispatch(md::FdEvent::readable);
 
     EXPECT_TRUE(handler_called);
-    EXPECT_EQ(mir_event_type_motion, ev.type);
+    EXPECT_EQ(mir::capnp::Event::Which::MOTION_SET, ev->which());
 }
 
 TEST_F(AndroidInputReceiverSetup, finish_signalled_after_handler)

=== modified file 'tests/unit-tests/client/input/test_xkb_mapper.cpp'
--- tests/unit-tests/client/input/test_xkb_mapper.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/client/input/test_xkb_mapper.cpp	2016-03-16 18:27:24 +0000
@@ -39,7 +39,7 @@
                               0, scan_code, mir_input_event_modifier_none);
 
     mapper.update_state_and_map_event(*ev);
-    return ev->key.key_code;
+    return ev->event.getKey().getKeyCode();
 }
 
 }

=== modified file 'tests/unit-tests/client/test_event_distributor.cpp'
--- tests/unit-tests/client/test_event_distributor.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/client/test_event_distributor.cpp	2016-03-16 18:27:24 +0000
@@ -43,7 +43,7 @@
 
 MATCHER_P(MirEventTypeIs, type, "")
 {
-    return (arg.type == type);
+    return (arg.event.asReader().which() == type);
 }
 
 }
@@ -56,10 +56,10 @@
     event_distributor.register_event_handler([this](MirEvent const& event) { event_handled2(event); });
 
     MirEvent e;
-    e.type = mir_event_type_prompt_session_state_change;
+    e.event.initPromptSession();
 
-    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.type))).Times(1);
-    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.type))).Times(1);
+    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.event.which()))).Times(1);
+    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.event.which()))).Times(1);
     event_distributor.handle_event(e);
 }
 
@@ -72,10 +72,10 @@
     event_distributor.unregister_event_handler(reg_id2);
 
     MirEvent e;
-    e.type = mir_event_type_prompt_session_state_change;
+    e.event.initPromptSession();
 
-    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.type))).Times(1);
-    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.type))).Times(0);
+    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.event.which()))).Times(1);
+    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.event.which()))).Times(0);
     event_distributor.handle_event(e);
 }
 
@@ -93,10 +93,10 @@
     reg_id2 = event_distributor.register_event_handler([this](MirEvent const& event) { event_handled2(event); });
 
     MirEvent e;
-    e.type = mir_event_type_prompt_session_state_change;
+    e.event.initPromptSession();
 
-    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.type))).Times(1);
-    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.type))).Times(0);
+    EXPECT_CALL(*this, event_handled1(MirEventTypeIs(e.event.which()))).Times(1);
+    EXPECT_CALL(*this, event_handled2(MirEventTypeIs(e.event.which()))).Times(0);
     event_distributor.handle_event(e);
 }
 
@@ -135,7 +135,7 @@
     };
 
     MirEvent e;
-    e.type = mir_event_type_prompt_session_state_change;
+    e.event.initPromptSession();
 
     std::vector<EventCatcher*> catchers;
     for (int p = 0; p < 10; p++)

=== modified file 'tests/unit-tests/input/android/test_android_input_sender.cpp'
--- tests/unit-tests/input/android/test_android_input_sender.cpp	2016-03-16 06:59:01 +0000
+++ tests/unit-tests/input/android/test_android_input_sender.cpp	2016-03-16 18:27:24 +0000
@@ -44,7 +44,6 @@
 
 #include <boost/exception/all.hpp>
 
-//#include <algorithm>
 #include <cstring>
 
 namespace mi = mir::input;

=== modified file 'tests/unit-tests/input/test_input_event.cpp'
--- tests/unit-tests/input/test_input_event.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/input/test_input_event.cpp	2016-03-16 18:27:24 +0000
@@ -23,6 +23,7 @@
 #include "mir_toolkit/events/input/input_event.h"
 
 using namespace testing;
+namespace mcap = mir::capnp;
 
 // See: https://bugs.launchpad.net/mir/+bug/1311699
 #define MIR_EVENT_ACTION_POINTER_INDEX_MASK 0xff00
@@ -61,40 +62,6 @@
     AINPUT_SOURCE_ANY = 0xffffff00
 };
 
-MirEvent a_key_ev()
-{
-    MirEvent key_ev;
-    memset(&key_ev, 0, sizeof(key_ev));
-    
-    key_ev.type = mir_event_type_key;
-    
-    return key_ev;
-}
-
-MirEvent a_motion_ev(int device_class = AINPUT_SOURCE_UNKNOWN)
-{
-    MirEvent motion_ev;
-    memset(&motion_ev, 0, sizeof(motion_ev));
-    
-    motion_ev.type = mir_event_type_motion;
-    motion_ev.motion.source_id = device_class;
-    
-    return motion_ev;
-}
-
-}
-
-TEST(InputEvent, old_style_key_and_motion_events_are_input_events)
-{
-    auto key_ev = a_key_ev();
-    
-    EXPECT_EQ(mir_event_type_input, mir_event_get_type(&key_ev));
-    EXPECT_EQ(mir_input_event_type_key, mir_input_event_get_type(mir_event_get_input_event(&key_ev)));
-
-    auto motion_ev = a_motion_ev();
-    
-    EXPECT_EQ(mir_event_type_input, mir_event_get_type(&motion_ev));
-    EXPECT_NE(nullptr, mir_event_get_input_event(&motion_ev));
 }
 
 // MirInputEvent properties common to all events.
@@ -102,43 +69,52 @@
 TEST(CommonInputEventProperties, device_id_taken_from_old_style_event)
 {
     int64_t dev_id_1 = 17, dev_id_2 = 23;
-    auto old_ev = a_motion_ev();
-
-    old_ev.type = mir_event_type_motion;
-    old_ev.motion.device_id = dev_id_1;
+    MirEvent old;
+    old->initMotionSet();
+
+    auto device = old->getMotionSet().getDeviceId();
+    device.setId(dev_id_1);
+
     EXPECT_EQ(dev_id_1, mir_input_event_get_device_id(
-        mir_event_get_input_event(&old_ev)));
+        mir_event_get_input_event(&old)));
 
-    old_ev.type = mir_event_type_key;
-    old_ev.motion.device_id = dev_id_2;
+    old->initKey();
+    device = old->getKey().getDeviceId();
+    device.setId(dev_id_2);
     EXPECT_EQ(dev_id_2, mir_input_event_get_device_id(
-        mir_event_get_input_event(&old_ev)));
+        mir_event_get_input_event(&old)));
 }
 
 TEST(CommonInputEventProperties, event_time_taken_from_old_style_event)
 {
     std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
-    auto old_ev = a_motion_ev();
+    MirEvent old;
+    old->initMotionSet();
 
-    old_ev.motion.event_time = event_time_1;
+    auto nanoseconds = old->getMotionSet().getEventTime();
+    nanoseconds.setCount(event_time_1.count());
     EXPECT_EQ(event_time_1.count(), mir_input_event_get_event_time(
-        mir_event_get_input_event(&old_ev)));
+        mir_event_get_input_event(&old)));
 
-    old_ev.type = mir_event_type_key;
-    old_ev.key.event_time = event_time_2;
+    old->initKey();
+    nanoseconds = old->getKey().getEventTime();
+    nanoseconds.setCount(event_time_2.count());
     EXPECT_EQ(event_time_2.count(), mir_input_event_get_event_time(
-        mir_event_get_input_event(&old_ev)));
+        mir_event_get_input_event(&old)));
 }
 
 TEST(KeyInputEventProperties, timestamp_taken_from_old_style_event)
 {
     std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
-    auto old_ev = a_key_ev();
-    auto const keyboard_event = mir_input_event_get_keyboard_event(mir_event_get_input_event(&old_ev));
+    MirEvent key;
+    key->initKey();
+
+    auto const keyboard_event = mir_input_event_get_keyboard_event(mir_event_get_input_event(&key));
 
     for (auto expected : {event_time_1, event_time_2})
     {
-        old_ev.key.event_time = expected;
+        auto nanoseconds = key->getKey().getEventTime();
+        nanoseconds.setCount(expected.count());
 
         auto const input_event = mir_keyboard_event_input_event(keyboard_event);
 
@@ -149,14 +125,15 @@
 
 TEST(KeyInputEventProperties, up_and_down_actions_copied_from_old_style_event)
 {
-    auto old_ev = a_key_ev();
+    MirEvent key;
+    key->initKey();
 
-    old_ev.key.action = mir_keyboard_action_down;
+    key->getKey().setAction(static_cast<mcap::KeyboardEvent::Action>(mir_keyboard_action_down));
     
-    auto new_kev = mir_input_event_get_keyboard_event(mir_event_get_input_event(&old_ev));
+    auto new_kev = mir_input_event_get_keyboard_event(mir_event_get_input_event(&key));
     EXPECT_EQ(mir_keyboard_action_down, mir_keyboard_event_action(new_kev));
 
-    old_ev.key.action = mir_keyboard_action_up;
+    key->getKey().setAction(static_cast<mcap::KeyboardEvent::Action>(mir_keyboard_action_up));
     EXPECT_EQ(mir_keyboard_action_up, mir_keyboard_event_action(new_kev));
 }
 
@@ -166,12 +143,13 @@
     int scan_code = 31;
     MirInputEventModifiers modifiers = mir_input_event_modifier_shift;
 
-    auto old_ev = a_key_ev();
-    old_ev.key.key_code = key_code;
-    old_ev.key.scan_code = scan_code;
-    old_ev.key.modifiers = modifiers;
+    MirEvent key;
+    key->initKey();
+    key->getKey().setKeyCode(key_code);
+    key->getKey().setScanCode(scan_code);
+    key->getKey().setModifiers(modifiers);
 
-    auto new_kev = mir_input_event_get_keyboard_event(mir_event_get_input_event(&old_ev));
+    auto new_kev = mir_input_event_get_keyboard_event(mir_event_get_input_event(&key));
     EXPECT_EQ(key_code, mir_keyboard_event_key_code(new_kev));
     EXPECT_EQ(scan_code, mir_keyboard_event_scan_code(new_kev));
     EXPECT_EQ(modifiers, mir_keyboard_event_modifiers(new_kev));
@@ -179,13 +157,16 @@
 
 TEST(TouchEventProperties, timestamp_taken_from_old_style_event)
 {
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
     std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-    auto const touch_event = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    auto const touch_event = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
 
     for (auto expected : {event_time_1, event_time_2})
     {
-        old_ev.motion.event_time = expected;
+        auto nanoseconds = motion->getMotionSet().getEventTime();
+        nanoseconds.setCount(expected.count());
 
         auto const input_event = mir_touch_event_input_event(touch_event);
 
@@ -196,48 +177,61 @@
 TEST(TouchEventProperties, touch_count_taken_from_pointer_count)
 {
     unsigned const pointer_count = 3;
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-
-    old_ev.motion.pointer_count = pointer_count;
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+    motion->getMotionSet().setCount(pointer_count);
     
-    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(pointer_count, mir_touch_event_point_count(tev));
 }
 
 TEST(TouchEventProperties, touch_id_comes_from_pointer_coordinates)
 {
     unsigned const touch_id = 31;
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-
-    old_ev.motion.pointer_count = 1;
-    old_ev.motion.pointer_coordinates[0].id = touch_id;
-
-    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+
+    motion->getMotionSet().setCount(1);
+    motion->getMotionSet().initMotions(1);
+    motion->getMotionSet().getMotions()[0].setId(touch_id);
+
+    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(touch_id, mir_touch_event_id(tev, 0));
 }
 
 // mir_motion_action_up/down represent the start of a gesture. pointers only go up/down one at a time
 TEST(TouchEventProperties, down_and_up_actions_are_taken_from_old_event)
 {
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-    old_ev.motion.pointer_count = 1;
-    old_ev.motion.pointer_coordinates[0].action = mir_touch_action_change;
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+    motion->getMotionSet().setCount(1);
+    motion->getMotionSet().initMotions(1);
+    motion->getMotionSet().getMotions()[0].setAction(mir_touch_action_change);
 
-    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(mir_touch_action_change, mir_touch_event_action(tev, 0));
 }
 
 TEST(TouchEventProperties, tool_type_copied_from_old_pc)
 {
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-
-    auto& old_mev = old_ev.motion;
-    old_mev.pointer_count = 3;
-    old_mev.pointer_coordinates[0].tool_type = mir_touch_tooltype_unknown;
-    old_mev.pointer_coordinates[1].tool_type = mir_touch_tooltype_finger;
-    old_mev.pointer_coordinates[2].tool_type = mir_touch_tooltype_stylus;
-
-    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+
+    auto mev = motion->getMotionSet();
+    mev.setCount(3);
+    motion->getMotionSet().initMotions(3);
+    mev.getMotions()[0].setToolType(
+        static_cast<mcap::MotionEventSet::Motion::ToolType>(mir_touch_tooltype_unknown));
+    mev.getMotions()[1].setToolType(
+        static_cast<mcap::MotionEventSet::Motion::ToolType>(mir_touch_tooltype_finger));
+    mev.getMotions()[2].setToolType(
+        static_cast<mcap::MotionEventSet::Motion::ToolType>(mir_touch_tooltype_stylus));
+
+    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(mir_touch_tooltype_unknown, mir_touch_event_tooltype(tev, 0));
     EXPECT_EQ(mir_touch_tooltype_finger, mir_touch_event_tooltype(tev, 1));
     EXPECT_EQ(mir_touch_tooltype_stylus, mir_touch_event_tooltype(tev, 2));
@@ -246,17 +240,20 @@
 TEST(TouchEventProperties, axis_values_used_by_qtmir_copied)
 {
     float x_value = 19, y_value = 23, touch_major = .3, touch_minor = .2, pressure = .9, size = 1111;
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
-    old_ev.motion.pointer_count = 1;
-    auto &old_pc = old_ev.motion.pointer_coordinates[0];
-    old_pc.x = x_value;
-    old_pc.y = y_value;
-    old_pc.touch_major = touch_major;
-    old_pc.touch_minor = touch_minor;
-    old_pc.pressure = pressure;
-    old_pc.size = size;
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_TOUCHSCREEN);
+    motion->getMotionSet().setCount(3);
+    motion->getMotionSet().initMotions(3);
+    auto pc = motion->getMotionSet().getMotions()[0];
+    pc.setX(x_value);
+    pc.setY(y_value);
+    pc.setTouchMajor(touch_major);
+    pc.setTouchMinor(touch_minor);
+    pc.setPressure(pressure);
+    pc.setSize(size);
 
-    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&old_ev));
+    auto tev = mir_input_event_get_touch_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(x_value, mir_touch_event_axis_value(tev, 0, mir_touch_axis_x));
     EXPECT_EQ(y_value, mir_touch_event_axis_value(tev, 0, mir_touch_axis_y));
     EXPECT_EQ(touch_major, mir_touch_event_axis_value(tev, 0, mir_touch_axis_touch_major));
@@ -283,9 +280,11 @@
 TEST_P(DeviceClassTest, pointer_and_touch_events_differentiated_on_device_class)
 {
     auto const& param = GetParam();
-    auto old_ev = a_motion_ev(param.device_class);
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(param.device_class);
 
-    auto iev = mir_event_get_input_event(&old_ev);
+    auto iev = mir_event_get_input_event(&motion);
     EXPECT_EQ(param.expected_type, mir_input_event_get_type(iev));
 }
 
@@ -309,12 +308,15 @@
 TEST(PointerInputEventProperties, timestamp_taken_from_old_style_event)
 {
     std::chrono::nanoseconds event_time_1{79}, event_time_2{83};
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
-    auto const pointer_event = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_MOUSE);
+    auto const pointer_event = mir_input_event_get_pointer_event(mir_event_get_input_event(&motion));
 
     for (auto expected : {event_time_1, event_time_2})
     {
-        old_ev.motion.event_time = expected;
+        auto nanoseconds = motion->getMotionSet().getEventTime();
+        nanoseconds.setCount(expected.count());
 
         auto const input_event = mir_pointer_event_input_event(pointer_event);
 
@@ -325,25 +327,31 @@
 TEST(PointerInputEventProperties, modifiers_taken_from_old_style_ev)
 {
     MirInputEventModifiers modifiers = mir_input_event_modifier_shift;
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
-    old_ev.motion.modifiers = modifiers;
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_MOUSE);
+    motion->getMotionSet().setModifiers(modifiers);
     
     auto pointer_event = 
-        mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
+        mir_input_event_get_pointer_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(modifiers, mir_pointer_event_modifiers(pointer_event));
 }
 
 TEST(PointerInputEventProperties, button_state_translated)
 {
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_MOUSE);
+    auto mev = motion->getMotionSet();
 
-    old_ev.motion.buttons = mir_pointer_button_primary;
-    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
+    mev.setButtons(mir_pointer_button_primary);
+    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&motion));
     
     EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
     EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
 
-    old_ev.motion.buttons |=  mir_pointer_button_secondary;
+    auto buttons = mev.getButtons() | mir_pointer_button_secondary;
+    mev.setButtons(buttons);
 
     EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
     EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
@@ -356,14 +364,18 @@
 TEST(PointerInputEventProperties, axis_values_copied)
 {
     float x = 7, y = 9.3, hscroll = 13, vscroll = 17;
-    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
-    old_ev.motion.pointer_count = 0;
-    old_ev.motion.pointer_coordinates[0].x = x;
-    old_ev.motion.pointer_coordinates[0].y = y;
-    old_ev.motion.pointer_coordinates[0].vscroll = vscroll;
-    old_ev.motion.pointer_coordinates[0].hscroll = hscroll;
+    MirEvent motion;
+    motion->initMotionSet();
+    motion->getMotionSet().setSourceId(AINPUT_SOURCE_MOUSE);
+    auto mev = motion->getMotionSet();
+    mev.setCount(1);
+    mev.initMotions(1);
+    mev.getMotions()[0].setX(x);
+    mev.getMotions()[0].setY(y);
+    mev.getMotions()[0].setVscroll(vscroll);
+    mev.getMotions()[0].setHscroll(hscroll);
 
-    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
+    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&motion));
     EXPECT_EQ(x, mir_pointer_event_axis_value(pev, mir_pointer_axis_x));
     EXPECT_EQ(y, mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
     EXPECT_EQ(vscroll, mir_pointer_event_axis_value(pev, mir_pointer_axis_vscroll));

=== modified file 'tests/unit-tests/input/test_surface_input_dispatcher.cpp'
--- tests/unit-tests/input/test_surface_input_dispatcher.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/input/test_surface_input_dispatcher.cpp	2016-03-16 18:27:24 +0000
@@ -264,7 +264,7 @@
     FakeKeyboard keyboard;
     auto event = keyboard.press();
 
-    EXPECT_CALL(*surface, consume(mt::MirKeyboardEventMatches(*event))).Times(1);
+    EXPECT_CALL(*surface, consume(mt::MirKeyboardEventMatches(event.get()))).Times(1);
 
     dispatcher.start();
 
@@ -307,7 +307,7 @@
     auto down_event = keyboard.press();
     auto up_event = keyboard.release();
 
-    EXPECT_CALL(*surface_1, consume(mt::MirKeyboardEventMatches(*down_event))).Times(1);
+    EXPECT_CALL(*surface_1, consume(mt::MirKeyboardEventMatches(down_event.get()))).Times(1);
     EXPECT_CALL(*surface_2, consume(_)).Times(0);
 
     dispatcher.start();
@@ -326,7 +326,7 @@
     auto event = keyboard.press();
 
     InSequence seq;
-    EXPECT_CALL(*surface, consume(mt::MirKeyboardEventMatches(*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-01-29 08:18:22 +0000
+++ tests/unit-tests/input/test_validator.cpp	2016-03-16 18:27:24 +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(*inserted_down_id0)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_down_id1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_release)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_3)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_release_id1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_release_id0)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_3)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_release_id1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_down_id2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_up_id0)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_down_id2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_2)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_3)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*touch_4)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_down_id1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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(*touch_1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_up_id0)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*inserted_down_id1)));
-    EXPECT_CALL(input_sink, handle(mt::MirTouchEventMatches(*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-03-16 06:59:01 +0000
+++ tests/unit-tests/scene/test_application_session.cpp	2016-03-16 18:27:24 +0000
@@ -95,7 +95,8 @@
 }
 
 MATCHER_P(EqPromptSessionEventState, state, "") {
-  return arg.type == mir_event_type_prompt_session_state_change && arg.prompt_session.new_state == state;
+    return arg->asReader().which() == mir::capnp::Event::Which::PROMPT_SESSION &&
+         arg->asReader().getPromptSession().getNewState() == static_cast<mir::capnp::PromptSessionEvent::State>(state);
 }
 
 MATCHER_P(HasParent, parent, "")
@@ -939,7 +940,7 @@
 
     for (int i = 0; i < 2 ; ++i)
     {
-        EXPECT_THAT(event[i].surface_output.surface_id, Eq(ids[i].as_value()));
+        EXPECT_THAT(event[i]->asReader().getSurfaceOutput().getSurfaceId(), Eq(ids[i].as_value()));
         EXPECT_THAT(&event[i], SurfaceOutputEventFor(*outputs[i]));
     }
 }
@@ -984,7 +985,7 @@
 
     ASSERT_TRUE(event_received);
 
-    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
+    EXPECT_THAT(event->asReader().getSurfaceOutput().getSurfaceId(), Eq(id.as_value()));
     EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
 }
 
@@ -1087,7 +1088,7 @@
     ASSERT_THAT(events_received, Ge(1));
     auto events_expected = events_received + 1;
 
-    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
+    EXPECT_THAT(event->asReader().getSurfaceOutput().getSurfaceId(), Eq(id.as_value()));
     EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
 
     // Now solely on the left output
@@ -1096,7 +1097,7 @@
     ASSERT_THAT(events_received, Eq(events_expected));
     events_expected++;
 
-    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
+    EXPECT_THAT(event->asReader().getSurfaceOutput().getSurfaceId(), Eq(id.as_value()));
     EXPECT_THAT(&event, SurfaceOutputEventFor(projector));
 
     // Now solely on the right output
@@ -1105,7 +1106,7 @@
     ASSERT_THAT(events_received, Eq(events_expected));
     events_expected++;
 
-    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
+    EXPECT_THAT(event->asReader().getSurfaceOutput().getSurfaceId(), Eq(id.as_value()));
     EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
 }
 

=== modified file 'tests/unit-tests/scene/test_surface.cpp'
--- tests/unit-tests/scene/test_surface.cpp	2016-01-29 08:18:22 +0000
+++ tests/unit-tests/scene/test_surface.cpp	2016-03-16 18:27:24 +0000
@@ -414,8 +414,8 @@
     mev::add_touch(*touch_event, 0, mir_touch_action_down, mir_touch_tooltype_finger, 0, 0,
         0, 0, 0, 0);
 
-    EXPECT_CALL(mock_sender, send_event(mt::MirKeyboardEventMatches(*key_event), _)).Times(1);
-    EXPECT_CALL(mock_sender, send_event(mt::MirTouchEventMatches(*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-01-29 08:18:22 +0000
+++ tests/unit-tests/scene/test_surface_impl.cpp	2016-03-16 18:27:24 +0000
@@ -168,6 +168,29 @@
     EXPECT_EQ(expect_size, surface->size());
 }
 
+MATCHER_P(MirResizeEventMatches, event, "")
+{
+    auto arg_resize = arg->asReader().getResize();
+    auto arg_id     = arg_resize.getSurfaceId();
+    auto arg_width  = arg_resize.getWidth();
+    auto arg_height = arg_resize.getHeight();
+
+    auto resize = (*event)->asReader().getResize();
+    auto id     = resize.getSurfaceId();
+    auto width  = resize.getWidth();
+    auto height = resize.getHeight();
+
+    return arg_id     == id    &&
+           arg_width  == width &&
+           arg_height == height;
+}
+
+MATCHER_P(MirCloseSurfaceEventMatches, event, "")
+{
+    return arg->asReader().which() == (*event)->asReader().which();
+}
+
+
 TEST_F(Surface, emits_resize_events)
 {
     using namespace testing;
@@ -180,7 +203,7 @@
     surface->add_observer(observer);
 
     auto e = mev::make_event(stub_id, new_size);
-    EXPECT_CALL(*sink, handle_event(*e))
+    EXPECT_CALL(*sink, handle_event(MirResizeEventMatches(e.get())))
         .Times(1);
 
     surface->resize(new_size);
@@ -200,11 +223,11 @@
     surface->add_observer(observer);
 
     auto e = mev::make_event(stub_id, new_size);
-    EXPECT_CALL(*sink, handle_event(*e))
+    EXPECT_CALL(*sink, handle_event(MirResizeEventMatches(e.get())))
         .Times(1);
 
     auto e2 = mev::make_event(stub_id, new_size2);
-    EXPECT_CALL(*sink, handle_event(*e2))
+    EXPECT_CALL(*sink, handle_event(MirResizeEventMatches(e2.get())))
         .Times(1);
 
     surface->resize(new_size);
@@ -252,11 +275,10 @@
     surface->add_observer(observer);
 
     MirEvent e;
-    memset(&e, 0, sizeof e);
-    e.type = mir_event_type_close_surface;
-    e.close_surface.surface_id = stub_id.as_value();
+    e.event.initCloseSurface();
+    e.event.getCloseSurface().setSurfaceId(stub_id.as_value());
 
-    EXPECT_CALL(*sink, handle_event(e)).Times(1);
+    EXPECT_CALL(*sink, handle_event(MirCloseSurfaceEventMatches(&e))).Times(1);
 
     surface->request_client_surface_close();
 }