Merge lp:~cemil-azizoglu/mir/remove-deprecations-1 into lp:mir

[Cemil Azizoglu]

Remove some low-hanging deprecations. More to come.

There are more deprecations to be removed, low-hanging, or otherwise.

- The symbol stanza will later be collapsed into a new stanza. For now, I've deleted each removed function from its own stanza (though I went ahead and renamed the stanza for mir_debug to 1.0)
- Only tests that either don't make sense or have other coverage has been removed.

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

FAILED: Continuous integration, rev:4018
https://mir-jenkins.ubuntu.com/job/mir-ci/2946/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/3904/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/3990
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/3980
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/3980
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/3980
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/3931/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3931
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/3931/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/3931
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/3931/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/3931/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/3931/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3931
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/3931/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/3931
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/3931/artifact/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

[Cemil Azizoglu (cemil-azizoglu)]

00:55:52 Saving GLMark2 detailed results to: /tmp/GLMark2Test_fullscreen_default.log
00:55:52 glmark2-es2-mir: relocation error: glmark2-es2-mir: symbol mir_connection_create_spec_for_normal_surface, version MIR_CLIENT_9 not defined in file libmirclient.so.9 with link time reference
00:55:52 ../../../tests/performance-tests/test_glmark2-es2-mir.cpp:100: Failure
00:55:52 Value of: run_glmark2("--fullscreen")
00:55:52 Expected: is >= 56
00:55:52 Actual: -1 (of type int)
00:55:52 [2017-02-07 00:55:52.264989] mirserver: Stopping
00:55:52 [ FAILED ] GLMark2Test.fullscreen_default (853 ms)
00:55:52 [----------] 1 test from GLMark2Test (853 ms total)
00:55:52
00:55:52 [----------] Global test environment tear-down
00:55:52 [==========] 1 test from 1 test case ran. (853 ms total)
00:55:52 [ PASSED ] 0 tests.
00:55:52 [ FAILED ] 1 test, listed below:
00:55:52 [ FAILED ] GLMark2Test.fullscreen_default
00:55:52
00:55:52 1 FAILED TEST
00:55:52  YOU HAVE 5 DISABLED TESTS

Hmm we'll have to exclude GLMark2 for the time being.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

I think we should get downstreams rebuilt using the non-deprecated APIs before deleting the deprecated ones. (Not exclude them.)

review: Needs Resubmitting

Unmerged revisions

4018. By Cemil Azizoglu on 2017-02-07

One more persistent id rename

4017. By Cemil Azizoglu on 2017-02-06

Remove more deprecations

4016. By Cemil Azizoglu on 2017-02-06

Low hanging deprecations removed.

=== modified file 'include/client/mir/event_printer.h'
--- include/client/mir/event_printer.h	2017-01-19 05:30:03 +0000
+++ include/client/mir/event_printer.h	2017-02-07 00:07:50 +0000
@@ -34,20 +34,10 @@
 std::ostream& operator<<(std::ostream& out, MirPromptSessionState state);
 std::ostream& operator<<(std::ostream& out, MirOrientation orientation);
 
-std::ostream& operator<<(std::ostream& out, MirSurfaceAttrib attribute)
-__attribute__ ((deprecated("use << with MirWindowAttrib instead")));
 std::ostream& operator<<(std::ostream& out, MirWindowAttrib attribute);
-std::ostream& operator<<(std::ostream& out, MirSurfaceFocusState state)
-__attribute__ ((deprecated("use << with MirWindowFocusState instead")));
 std::ostream& operator<<(std::ostream& out, MirWindowFocusState state);
-std::ostream& operator<<(std::ostream& out, MirSurfaceVisibility state)
-__attribute__ ((deprecated("use << with MirWindowVisibility instead")));
 std::ostream& operator<<(std::ostream& out, MirWindowVisibility state);
-std::ostream& operator<<(std::ostream& out, MirSurfaceType type)
-__attribute__ ((deprecated("use << with MirWindowType instead")));
 std::ostream& operator<<(std::ostream& out, MirWindowType type);
-std::ostream& operator<<(std::ostream& out, MirSurfaceState state)
-__attribute__ ((deprecated("use << with MirWindowState instead")));
 std::ostream& operator<<(std::ostream& out, MirWindowState state);
 
 std::ostream& operator<<(std::ostream& out, MirPromptSessionEvent const& event);

=== modified file 'include/client/mir/events/event_builders.h'
--- include/client/mir/events/event_builders.h	2017-01-19 05:30:03 +0000
+++ include/client/mir/events/event_builders.h	2017-02-07 00:07:50 +0000
@@ -46,9 +46,6 @@
 EventUPtr make_event(MirPromptSessionState state);
 // Surface resize event
 EventUPtr make_event(frontend::SurfaceId const& surface_id, geometry::Size const& size);
-// Surface configure event
-EventUPtr make_event(frontend::SurfaceId const& surface_id, MirSurfaceAttrib attribute, int value)
-__attribute__ ((deprecated("use make_event with MirWindowAttribute instead")));
 // Window configure event
 EventUPtr make_event(frontend::SurfaceId const& surface_id, MirWindowAttrib attribute, int value);
 // Close surface event
@@ -78,47 +75,15 @@
 void set_cursor_position(MirEvent& event, float x, float y);
 void set_button_state(MirEvent& event, MirPointerButtons button_state);
 
-// Deprecated version with uint64_t mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t mac, MirKeyboardAction action, xkb_keysym_t key_code,
-    int scan_code, MirInputEventModifiers modifiers) __attribute__ ((deprecated));
-
-// Deprecated version without mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirKeyboardAction action, xkb_keysym_t key_code,
-    int scan_code, MirInputEventModifiers modifiers) __attribute__ ((deprecated));
-
 // Touch event
 EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
     std::vector<uint8_t> const& mac, MirInputEventModifiers modifiers);
 
-// Deprecated version with uint64_t mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t mac, MirInputEventModifiers modifiers) __attribute__ ((deprecated));
-
-// Deprecated version without mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers) __attribute__ ((deprecated));
-
 void add_touch(MirEvent &event, MirTouchId touch_id, MirTouchAction action,
     MirTouchTooltype tooltype, float x_axis_value, float y_axis_value,
     float pressure_value, float touch_major_value, float touch_minor_value, float size_value);
 
 // Pointer event
-// Deprecated version without relative axis
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t mac, MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value) __attribute__ ((deprecated));
-
-// Deprecated version without relative axis and mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value) __attribute__ ((deprecated));
-
 EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
     std::vector<uint8_t> const& mac, MirInputEventModifiers modifiers, MirPointerAction action,
     MirPointerButtons buttons_pressed,
@@ -126,26 +91,6 @@
     float hscroll_value, float vscroll_value,
     float relative_x_value, float relative_y_value);
 
-// Deprecated version with uint64_t mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t mac, MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value,
-    float relative_x_value, float relative_y_value) __attribute__ ((deprecated));
-
-// Deprecated version without mac
-EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value,
-    float relative_x_value, float relative_y_value) __attribute__ ((deprecated));
-
-// Input configuration event
-EventUPtr make_event(MirInputConfigurationAction action,
-    MirInputDeviceId id, std::chrono::nanoseconds time) __attribute__((deprecated));
-
 EventUPtr make_event(std::chrono::nanoseconds timestamp,
                      MirPointerButtons pointer_buttons,
                      MirInputEventModifiers modifiers,

=== modified file 'include/client/mir_toolkit/debug/surface.h'
--- include/client/mir_toolkit/debug/surface.h	2017-01-18 04:43:15 +0000
+++ include/client/mir_toolkit/debug/surface.h	2017-02-07 00:07:50 +0000
@@ -44,37 +44,6 @@
  */
 uint32_t mir_debug_window_current_buffer_id(MirWindow *window);
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-/**
- * Get the screen coordinates corresponding to a pair of surface coordinates
- * \pre                               The surface is valid
- * \param   [in] surface              The surface
- * \param   [in] x, y                 Surface coordinates to map to screen coordinates
- * \param   [out] screen_x, screen_y  The screen coordinates corresponding to x, y.
- * \return                            True if screen_x and screen_y contain values
- * \note    There are many cases where such a mapping does not exist or would be expensive
- *          to calculate. Only Mir servers started with the --debug option will ever return
- *          values for this call, and even when --debug is enabled servers are free to
- *          return nothing.
- *
- *          This call will only be interesting for automated testing, where both the client
- *          and shell state is known and constrained.
- */
-bool mir_debug_surface_coords_to_screen(MirSurface *surface,
-                                       int x, int y,
-                                       int* screen_x, int* screen_y)
-__attribute__((deprecated("Use mir_extension_window_coordinate_translation instead")));
-
-int mir_debug_surface_id(MirSurface *surface)
-__attribute__((deprecated("Use mir_debug_window_id() instead")));
-
-uint32_t mir_debug_surface_current_buffer_id(MirSurface *surface)
-__attribute__((deprecated("Use mir_debug_window_current_buffer_id() instead")));
-
-#pragma GCC diagnostic pop
-
 #ifdef __cplusplus
 }
 #endif

=== modified file 'include/client/mir_toolkit/events/event.h'
--- include/client/mir_toolkit/events/event.h	2017-01-27 04:57:53 +0000
+++ include/client/mir_toolkit/events/event.h	2017-02-07 00:07:50 +0000
@@ -89,7 +89,6 @@
 
 #include "mir_toolkit/events/input/input_event.h"
 #include "mir_toolkit/events/resize_event.h"
-#include "mir_toolkit/events/surface_event.h"
 #include "mir_toolkit/events/window_event.h"
 #include "mir_toolkit/events/orientation_event.h"
 #include "mir_toolkit/events/prompt_session_event.h"
@@ -128,19 +127,8 @@
 MirInputEvent const* mir_event_get_input_event(MirEvent const* event);
 
 /**
- * Retrieve the MirSurfaceEvent associated with a MirEvent of
- * type mir_event_type_surface. See <mir_toolkit/events/surface_event.h>
- * for accessors.
- *
- * \param [in] event The event
- * \return           The associated MirSurfaceEvent
- */
-MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* event)
-__attribute__ ((deprecated("use mir_event_get_window_event instead")));
-
-/**
  * Retrieve the MirWindowEvent associated with a MirEvent of
- * type mir_event_type_window. See <mir_toolkit/events/surface_event.h>
+ * type mir_event_type_window. See <mir_toolkit/events/window_event.h>
  * for accessors.
  *
  * \param [in] event The event
@@ -212,37 +200,6 @@
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/**
- * Retrieve the MirInputConfig associated with a MirEvent of
- * type mir_event_type_input_configuration. The event signifies that the
- * input device configuration has changed.
- *
- * \deprecated Input devices and changes to the input devices are indicated
- * via the MirInputConfigCallback
- * \param [in] event The event
- * \return           The associated MirInputConfigurationEvent
- */
-/// @cond
-__attribute__((deprecated))
-/// @endcond
-MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* event);
-#pragma GCC diagnostic pop
-
-/**
- * Retrieve the MirSurfaceOutputEvent associated with a MirEvent of type
- * mir_event_type_surface_output. The event signifies that the properties
- * of the output the surface is displayed upon have changed.
- *
- * A MirSurfaceOutputEvent is generated either when the properties of the
- * output the surface is primarily on change (for example: by user configuration
- * of resolution) or when the output the surface is primarily on changes
- * (for example: when a user moves the surface from one monitor to another).
- *
- * \param [in] event The event
- * \return           The associated MirSurfaceOutputEvent
- */
-MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* event)
-__attribute__((deprecated("use mir_event_get_window_output_event")));
 
 /**
  * Retrieve the MirWindowOutputEvent associated with a MirEvent of type
@@ -271,17 +228,6 @@
 MirInputDeviceStateEvent const* mir_event_get_input_device_state_event(MirEvent const* event);
 
 /**
- * Retrieve the MirSurfacePlacementEvent associated with a MirEvent of
- * type mir_event_type_surface_placement. The event signifies that the
- * the server has fulfilled a request for relative surface placement.
- *
- * \param [in] event The event
- * \return           The associated MirSurfacePlacementEvent
- */
-MirSurfacePlacementEvent const* mir_event_get_surface_placement_event(MirEvent const* event)
-__attribute__((deprecated("use mir_event_get_window_placement_event")));
-
-/**
  * Retrieve the MirWindowPlacementEvent associated with a MirEvent of
  * type mir_event_type_window_placement. The event signifies that the
  * the server has fulfilled a request for relative window placement.

=== modified file 'include/client/mir_toolkit/events/input_configuration_event.h'
--- include/client/mir_toolkit/events/input_configuration_event.h	2017-01-27 04:57:53 +0000
+++ include/client/mir_toolkit/events/input_configuration_event.h	2017-02-07 00:07:50 +0000
@@ -47,33 +47,6 @@
 } MirInputConfigurationAction
 __attribute__((deprecated));
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/**
- * Retrieve the input configuration action which occurred.
- *
- * \param[in] ev The input configuration event
- * \return       The action
- */
-MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* ev) __attribute__((deprecated));
-
-/**
- * Retreive the time associated with a MirInputConfiguration event
-
- * \param[in] ev The input configuration event
- * \return       The time in nanoseconds since epoch
- */
-int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* ev) __attribute__((deprecated));
-
-/**
- * Retreive the device id associated with a MirInputConfiguration event
-
- * \param[in] ev The input configuration event
- * \return       The device id or -1 if not applicable to events of this action
- */
-MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* ev) __attribute__((deprecated));
-#pragma GCC diagnostic pop
-
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/client/mir_toolkit/events/keymap_event.h'
--- include/client/mir_toolkit/events/keymap_event.h	2017-01-18 02:29:37 +0000
+++ include/client/mir_toolkit/events/keymap_event.h	2017-02-07 00:07:50 +0000
@@ -34,19 +34,6 @@
 /**
  * Retrieve the new keymap reported by this MirKeymapEvent
  *
- * \deprecated keymap credentials are no longer available use
- * mir_keymap_event_get_keymap_buffer instead.
- *
- * \param[in] ev The keymap event
- * \param[out] rules XKB rules describing the new keymap.
- */
-void mir_keymap_event_get_rules(MirKeymapEvent const* ev,
-                                struct xkb_rule_names* rules)
-    __attribute__ ((deprecated));
-
-/**
- * Retrieve the new keymap reported by this MirKeymapEvent
- *
  * The keymap buffer is only valid while the MirKeymapEvent is valid.
  * The buffer can be used via xkb_keymap_new_from_buffer
  * \param[in] ev The keymap event

=== modified file 'include/client/mir_toolkit/events/surface_event.h'
--- include/client/mir_toolkit/events/surface_event.h	2017-01-23 03:38:33 +0000
+++ include/client/mir_toolkit/events/surface_event.h	2017-02-07 00:07:50 +0000
@@ -29,28 +29,6 @@
 extern "C" {
 #endif
 
-// Ignore use of deprecate MirSurfaceEvent typedef in deprecated functions (for now)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/**
- * Retrieve the attribute index configured with a given MirSurfaceEvent
- *
- * \param [in] event The event
- * \return           The associated attribute
- */
-MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* event)
-__attribute__ ((deprecated("use mir_window_event_get_attribute instead")));
-
-/**
- * Retrieve the new value of the associated attribute for a given MirSurfaceEvent
- *
- * \param [in] event The event
- * \return           The associated attribute value
- */
-int mir_surface_event_get_attribute_value(MirSurfaceEvent const* event)
-__attribute__ ((deprecated("use make_event with mir_window_event_get_attribute_value instead")));
-#pragma GCC diagnostic pop
-
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/client/mir_toolkit/events/surface_output_event.h'
--- include/client/mir_toolkit/events/surface_output_event.h	2017-01-23 03:38:33 +0000
+++ include/client/mir_toolkit/events/surface_output_event.h	2017-02-07 00:07:50 +0000
@@ -29,61 +29,6 @@
 extern "C" {
 #endif
 
-// Ignore use of deprecate MirSurfaceOutputEvent typedef in deprecated functions (for now)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/**
- * Retrieve the DPI of the new output configuration of a MirSurfaceOutputEvent
- *
- * \param [in] ev   The event
- * \return          The new DPI value for the surface is primarily on.
- */
-int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev)
-__attribute__ ((deprecated("use mir_window_output_event_get_dpi instead")));
-
-/**
- * Retrieve the form factor of the new output configuration of a MirSurfaceOutputEvent
- *
- * \param [in] ev   The event
- * \return          The new form factor of the output the surface is primarily on.
- */
-MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev)
-__attribute__ ((deprecated("use mir_window_output_event_get_form_factor instead")));
-
-/**
- * Retrieve the suggested scaling factor of the new output configuration of a
- * MirSurfaceOutputEvent.
- *
- * \param [in] ev   The event
- * \return          The new scaling factor of the output the surface is primarily on.
- */
-float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev)
-__attribute__ ((deprecated("use mir_window_output_event_get_scale instead")));
-
-/**
- * Retrieve the maximum refresh rate of the output(s) associated with a
- * MirSurfaceOutputEvent. For variable refresh rate displays this represents
- * the maximum refresh rate of the display to aim for, rather than a measurement
- * of recent performance.
- *
- * \param [in] ev   The event
- * \return          The refresh rate in Hz
- */
-double mir_surface_output_event_get_refresh_rate(MirSurfaceOutputEvent const* ev)
-__attribute__ ((deprecated("use mir_window_output_event_get_refresh_rate instead")));
-
-/**
- * Retrieve the ID of the output this surface is on from a MirSurfaceOutputEvent
- *
- * \param [in] ev   The event
- * \return          The ID of the output the surface is currently considered to be on.
- *                  (From MirDisplayOutput::output_id)
- */
-uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const *ev)
-__attribute__ ((deprecated("use mir_window_output_event_get_output_id instead")));
-
-#pragma GCC diagnostic pop
-
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/client/mir_toolkit/events/surface_placement.h'
--- include/client/mir_toolkit/events/surface_placement.h	2017-01-19 05:30:03 +0000
+++ include/client/mir_toolkit/events/surface_placement.h	2017-02-07 00:07:50 +0000
@@ -31,15 +31,6 @@
 
 typedef struct MirSurfacePlacementEvent MirSurfacePlacementEvent;
 
-/**
- * Retrieve the relative position from a placement notification
- * 
- * \param [in] event  The placement event
- * \return            The position relative to the parent surface
- */
-MirRectangle mir_surface_placement_get_relative_position(MirSurfacePlacementEvent const* event)
-__attribute__ ((deprecated("use mir_window_placement_get_relative_position instead")));
-
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/client/mir_toolkit/mir_blob.h'
--- include/client/mir_toolkit/mir_blob.h	2017-01-19 05:30:03 +0000
+++ include/client/mir_toolkit/mir_blob.h	2017-02-07 00:07:50 +0000
@@ -29,15 +29,6 @@
 #endif
 
 /**
- * Create a blob from a display configuration
- *
- * \param [in] configuration  The display configuration
- * \return                 A blob
- */
-MirBlob* mir_blob_from_display_configuration(MirDisplayConfiguration* configuration)
-__attribute__ ((deprecated("use mir_blob_from_display_config instead")));
-
-/**
  * Create a blob from a display config
  *
  * \param [in] config  The display config
@@ -57,17 +48,6 @@
 MirBlob* mir_blob_onto_buffer(void const* buffer, size_t buffer_size);
 
 /**
- * Create a blob from a display configuration
- *
- * \warning will abort() if the blob doesn't represent a meaningful display configuration
- *
- * \param [in] blob        The blob
- * \return                 A display configuration
- */
-MirDisplayConfiguration* mir_blob_to_display_configuration(MirBlob* blob)
-__attribute__ ((deprecated("use mir_blob_to_display_config instead")));
-
-/**
  * Create a blob from a display config
  *
  * \warning will abort() if the blob doesn't represent a meaningful display config

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2017-02-02 19:17:46 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2017-02-07 00:07:50 +0000
@@ -33,7 +33,6 @@
 #include <mir_toolkit/mir_display_configuration.h>
 #include <mir_toolkit/mir_input_device.h>
 #include <mir_toolkit/mir_error.h>
-#include <mir_toolkit/mir_persistent_id.h>
 #include <mir_toolkit/mir_window_id.h>
 
 #endif /* MIR_CLIENT_LIBRARY_H */

=== modified file 'include/client/mir_toolkit/mir_connection.h'
--- include/client/mir_toolkit/mir_connection.h	2017-01-31 19:33:32 +0000
+++ include/client/mir_toolkit/mir_connection.h	2017-02-07 00:07:50 +0000
@@ -87,27 +87,6 @@
 void mir_connection_release(MirConnection *connection);
 
 /**
- * Query platform-specific data and/or file descriptors that are required to
- * initialize GL/EGL features.
- *   \param [in]  connection        The connection
- *   \param [out] platform_package  Structure to be populated
- */
-void mir_connection_get_platform(MirConnection *connection, MirPlatformPackage *platform_package)
-__attribute__((deprecated("use platform extensions instead")));
-
-/**
- * Query graphics platform module.
- *
- * \note The char pointers in MirModuleProperties are owned by the connection and should not be
- * freed. They remain valid until the connection is released.
- *
- *   \param [in]  connection    The connection
- *   \param [out] properties    Structure to be populated
- */
-void mir_connection_get_graphics_module(MirConnection *connection, MirModuleProperties *properties)
-__attribute__((deprecated("use graphics module extension instead")));
-
-/**
  * Register a callback to be called when a Lifecycle state change occurs.
  *   \param [in] connection     The connection
  *   \param [in] callback       The function to be called when the state change occurs
@@ -364,24 +343,6 @@
     unsigned const int formats_size, unsigned int *num_valid_formats);
 
 /**
- * Perform a platform specific operation.
- *
- * The MirPlatformMessage used for the request needs to remain valid
- * until this operation finishes.
- *
- * \param [in] connection  The connection
- * \param [in] request     The message used for this operation
- * \param [in] callback    The callback to call when the operation finishes
- * \param [in,out] context User data passed to the callback function
- * \return                 A handle that can be passed to mir_wait_for
- */
-MirWaitHandle* mir_connection_platform_operation(
-    MirConnection* connection,
-    MirPlatformMessage const* request,
-    MirPlatformOperationCallback callback, void* context)
-__attribute__ ((deprecated("use platform specific extensions instead")));
-
-/**
  * Create a snapshot of the attached input devices and device configurations.
  * \warning return value must be destroyed via mir_input_config_release()
  * \warning may return null if connection is invalid

=== modified file 'include/client/mir_toolkit/mir_display_configuration.h'
--- include/client/mir_toolkit/mir_display_configuration.h	2017-01-27 04:57:53 +0000
+++ include/client/mir_toolkit/mir_display_configuration.h	2017-02-07 00:07:50 +0000
@@ -263,15 +263,6 @@
 /**
  * Get the textual name of an output type.
  *
- * \param [in]  type  The MirDisplayOutputType to describe.
- * \returns           The name of the output type.
- */
-char const* mir_display_output_type_name(MirDisplayOutputType type)
-__attribute__((deprecated("use mir_output_type_name instead")));
-
-/**
- * Get the textual name of an output type.
- *
  * \param [in]  type  The MirOutputType to describe.
  * \returns           The name of the output type.
  */

=== removed file 'include/client/mir_toolkit/mir_persistent_id.h'
--- include/client/mir_toolkit/mir_persistent_id.h	2017-02-01 19:54:40 +0000
+++ include/client/mir_toolkit/mir_persistent_id.h	1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-/*
- * Copyright © 2017 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef MIR_TOOLKIT_MIR_PERSISTENT_ID_H_
-#define MIR_TOOLKIT_MIR_PERSISTENT_ID_H_
-
-#include <mir_toolkit/client_types.h>
-
-#include <stdbool.h>
-
-#ifdef __cplusplus
-/**
- * \addtogroup mir_toolkit
- * @{
- */
-extern "C" {
-#endif
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/**
- * \brief Check the validity of a MirPersistentId
- * \param [in] id  The MirPersistentId
- * \return True iff the MirPersistentId contains a valid ID value.
- *
- * \note This does not guarantee that the ID refers to a currently valid object.
- */
-bool mir_persistent_id_is_valid(MirPersistentId* id)
-__attribute__((deprecated("Use mir_window_id_is_valid() instead")));
-
-/**
- * \brief Free a MirPersistentId
- * \param [in] id  The MirPersistentId to free
- * \note This frees only the client-side representation; it has no effect on the
- *       object referred to by \arg id.
- */
-void mir_persistent_id_release(MirPersistentId* id)
-__attribute__((deprecated("Use mir_window_id_release() instead")));
-
-/**
- * \brief Get a string representation of a MirSurfaceId
- * \param [in] id  The ID to serialise
- * \return A string representation of id. This string is owned by the MirSurfaceId,
- *         and must not be freed by the caller.
- *
- * \see mir_surface_id_from_string
- */
-char const* mir_persistent_id_as_string(MirPersistentId* id)
-__attribute__((deprecated("Use mir_window_id_as_string() instead")));
-
-/**
- * \brief Deserialise a string representation of a MirSurfaceId
- * \param [in] string_representation  Serialised representation of the ID
- * \return The deserialised MirSurfaceId
- */
-MirPersistentId* mir_persistent_id_from_string(char const* string_representation)
-__attribute__((deprecated("Use mir_window_id_from_string() instead")));
-
-#pragma GCC diagnostic pop
-
-#ifdef __cplusplus
-}
-/**@}*/
-#endif
-
-#endif /* MIR_TOOLKIT_MIR_PERSISTENT_ID_H_ */

=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2017-01-24 11:06:35 +0000
+++ include/client/mir_toolkit/mir_surface.h	2017-02-07 00:07:50 +0000
@@ -33,212 +33,6 @@
 extern "C" {
 #endif
 
-// Functions in this pragma section are to be deprecated
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-MirSurfaceSpec* mir_connection_create_spec_for_normal_surface(MirConnection* connection,
-                                                              int width, int height,
-                                                              MirPixelFormat format)
-__attribute__((deprecated("Use mir_create_normal_window_spec() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_menu(MirConnection* connection,
-                                    int width,
-                                    int height,
-                                    MirPixelFormat format,
-                                    MirSurface* parent,
-                                    MirRectangle* rect,
-                                    MirEdgeAttachment edge)
-__attribute__((deprecated("Use mir_specify_menu() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_tooltip(MirConnection* connection,
-                                       int width, int height,
-                                       MirPixelFormat format,
-                                       MirSurface* parent,
-                                       MirRectangle* zone)
-__attribute__((deprecated("Use mir_create_tip_window_spec() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_tip(MirConnection* connection,
-                                   int width, int height,
-                                   MirPixelFormat format,
-                                   MirSurface* parent,
-                                   MirRectangle* rect,
-                                   MirEdgeAttachment edge)
-__attribute__((deprecated("Use mir_create_tip_window_spec() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_modal_dialog(MirConnection* connection,
-                                            int width, int height,
-                                            MirPixelFormat format,
-                                            MirSurface* parent)
-__attribute__((deprecated("Use mir_create_modal_dialog_window_spec() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_dialog(MirConnection* connection,
-                                      int width, int height,
-                                      MirPixelFormat format)
-__attribute__((deprecated("Use mir_create_dialog_window_spec() instead")));
-
-MirSurfaceSpec* mir_create_surface_spec(MirConnection* connection)
-__attribute__((deprecated("Use mir_create_window_spec() instead")));
-
-MirSurfaceSpec*
-mir_connection_create_spec_for_changes(MirConnection* connection)
-__attribute__((deprecated("Use mir_create_window_spec() instead")));
-
-void mir_surface_spec_set_parent(MirSurfaceSpec* spec, MirSurface* parent)
-__attribute__((deprecated("Use mir_window_spec_set_parent() instead")));
-
-/**
- *\deprecated This will soon be a property of the backing content.
- *
- * Query the swapinterval that the surface is operating with.
- * The default interval is 1.
- *   \param [in] surface  The surface to operate on
- *   \return              The swapinterval value that the client is operating with.
- *                        Returns -1 if surface is invalid, or if the default stream
- *                        was removed by use of mir_window_spec_set_streams().
- */
-int mir_surface_get_swapinterval(MirSurface* surface)
-__attribute__((deprecated("This will soon be a property of the backing content")));
-
-void mir_surface_spec_set_type(MirSurfaceSpec* spec, MirSurfaceType type)
-__attribute__((deprecated("use mir_window_spec_set_type() instead")));
-
-void mir_surface_spec_set_name(MirSurfaceSpec* spec, char const* name)
-__attribute__((deprecated("use mir_window_spec_set_name() instead")));
-
-void mir_surface_spec_set_width(MirSurfaceSpec* spec, unsigned width)
-__attribute__((deprecated("use mir_window_spec_set_width() instead")));
-
-void mir_surface_spec_set_height(MirSurfaceSpec* spec, unsigned height)
-__attribute__((deprecated("use mir_window_spec_set_height() instead")));
-
-void mir_surface_spec_set_width_increment(MirSurfaceSpec* spec, unsigned width_inc)
-__attribute__((deprecated("use mir_window_spec_set_width_increment() instead")));
-
-void mir_surface_spec_set_height_increment(MirSurfaceSpec* spec, unsigned height_inc)
-__attribute__((deprecated("use mir_window_spec_set_height_increment() instead")));
-
-void mir_surface_spec_set_min_width(MirSurfaceSpec* spec, unsigned min_width)
-__attribute__((deprecated("use mir_window_spec_set_min_width() instead")));
-
-void mir_surface_spec_set_min_height(MirSurfaceSpec* spec, unsigned min_height)
-__attribute__((deprecated("use mir_window_spec_set_min_height() instead")));
-
-void mir_surface_spec_set_max_width(MirSurfaceSpec* spec, unsigned max_width)
-__attribute__((deprecated("use mir_window_spec_set_max_width() instead")));
-
-void mir_surface_spec_set_max_height(MirSurfaceSpec* spec, unsigned max_height)
-__attribute__((deprecated("use mir_window_spec_set_max_height() instead")));
-
-void mir_surface_spec_set_min_aspect_ratio(MirSurfaceSpec* spec, unsigned width, unsigned height)
-__attribute__((deprecated("use mir_window_spec_set_min_aspect_ratio() instead")));
-
-void mir_surface_spec_set_max_aspect_ratio(MirSurfaceSpec* spec, unsigned width, unsigned height)
-__attribute__((deprecated("use mir_window_spec_set_max_aspect_ratio() instead")));
-
-void mir_surface_spec_set_fullscreen_on_output(MirSurfaceSpec* spec, uint32_t output_id)
-__attribute__((deprecated("use mir_window_spec_set_fullscreen_on_output() instead")));
-
-void mir_surface_spec_set_preferred_orientation(MirSurfaceSpec* spec, MirOrientationMode mode)
-__attribute__((deprecated("use mir_window_spec_set_preferred_orientation() instead")));
-
-bool mir_surface_spec_attach_to_foreign_parent(MirSurfaceSpec* spec,
-                                               MirPersistentId* parent,
-                                               MirRectangle* attachment_rect,
-                                               MirEdgeAttachment edge)
-__attribute__((deprecated("use mir_window_spec_attach_to_foreign_parent() instead")));
-
-void mir_surface_spec_set_state(MirSurfaceSpec* spec, MirSurfaceState state)
-__attribute__((deprecated("use mir_window_spec_set_state() instead")));
-
-void mir_surface_spec_release(MirSurfaceSpec* spec)
-__attribute__((deprecated("use mir_window_spec_release() instead")));
-
-void mir_surface_spec_set_input_shape(MirSurfaceSpec* spec,
-                                      MirRectangle const *rectangles,
-                                      size_t n_rects)
-__attribute__((deprecated("use mir_window_spec_set_input_shape() instead")));
-
-void mir_surface_spec_set_event_handler(MirSurfaceSpec* spec,
-                                        mir_surface_event_callback callback,
-                                        void* context)
-__attribute__((deprecated("use mir_window_spec_set_event_handler() instead")));
-
-void mir_surface_spec_set_shell_chrome(MirSurfaceSpec* spec, MirShellChrome style)
-__attribute__((deprecated("use mir_window_spec_set_shell_chrome() instead")));
-
-void mir_surface_spec_set_pointer_confinement(MirSurfaceSpec* spec, MirPointerConfinementState state)
-__attribute__((deprecated("use mir_window_spec_set_pointer_confinement() instead")));
-
-void mir_surface_spec_set_placement(MirSurfaceSpec*     spec,
-                                    const MirRectangle* rect,
-                                    MirPlacementGravity rect_gravity,
-                                    MirPlacementGravity window_gravity,
-                                    MirPlacementHints   placement_hints,
-                                    int                 offset_dx,
-                                    int                 offset_dy)
-__attribute__((deprecated("use mir_window_spec_set_placement() instead")));
-
-MirSurfaceSpec* mir_connection_create_spec_for_input_method(MirConnection* connection,
-                                                            int width, int height,
-                                                            MirPixelFormat format)
-__attribute__((deprecated("use mir_create_input_method_window_spec() instead")));
-
-void mir_surface_spec_set_pixel_format(MirSurfaceSpec* spec, MirPixelFormat format)
-__attribute__((deprecated("use mir_window_spec_set_pixel_format() instead")));
-
-void mir_surface_spec_set_buffer_usage(MirSurfaceSpec* spec, MirBufferUsage usage)
-__attribute__((deprecated("use mir_window_spec_set_buffer_usage() instead")));
-
-void mir_surface_spec_set_streams(MirSurfaceSpec* spec,
-                                  MirBufferStreamInfo* streams,
-                                  unsigned int num_streams)
-__attribute__((deprecated("use mir_window_spec_set_streams() instead")));
-
-void mir_surface_apply_spec(MirSurface* surface, MirSurfaceSpec* spec)
-__attribute__((deprecated("use mir_window_apply_spec() instead")));
-
-bool mir_surface_is_valid(MirSurface *surface)
-__attribute__((deprecated("use mir_window_is_valid() instead")));
-
-MirWaitHandle* mir_surface_create(MirSurfaceSpec* requested_specification,
-                                  mir_surface_callback callback, void* context)
-__attribute__((deprecated("use mir_create_window() instead")));
-
-MirSurface* mir_surface_create_sync(MirSurfaceSpec* requested_specification)
-__attribute__((deprecated("use mir_create_window_sync() instead")));
-
-MirWaitHandle *mir_surface_release(
-    MirSurface *surface,
-    mir_surface_callback callback,
-    void *context)
-__attribute__((deprecated("use mir_window_release() instead")));
-
-void mir_surface_release_sync(MirSurface *surface)
-__attribute__((deprecated("use mir_window_release_sync() instead")));
-
-void mir_surface_set_event_handler(MirSurface *surface,
-                                   mir_surface_event_callback callback,
-                                   void* context)
-__attribute__((deprecated("use mir_window_set_event_handler() instead")));
-
-MirBufferStream* mir_surface_get_buffer_stream(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_buffer_stream() instead")));
-
-char const* mir_surface_get_error_message(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_error_message() instead")));
-
-void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters)
-__attribute__((deprecated("use mir_window_get_parameters() instead")));
-
-MirSurfaceType mir_surface_get_type(MirSurface* surface)
-__attribute__((deprecated("use mir_window_get_type() instead")));
-
 MirWaitHandle* mir_surface_set_state(MirSurface *surface,
                                      MirSurfaceState state)
 __attribute__((deprecated("use mir_window_set_state() instead")));
@@ -246,54 +40,9 @@
 MirSurfaceState mir_surface_get_state(MirSurface *surface)
 __attribute__((deprecated("use mir_window_get_state() instead")));
 
-/**
- * Set the swapinterval for the default stream.
- *   \warning EGL users should use eglSwapInterval directly.
- *   \warning If the surface was created with, or modified to have a
- *            MirSurfaceSpec containing streams added through
- *            mir_window_spec_set_streams(), the default stream will
- *            be removed, and this function will return NULL.
- *   \param [in] surface  The surface to operate on
- *   \param [in] interval The number of vblank signals that
- *                        mir_surface_swap_buffers will wait for
- *   \return              A wait handle that can be passed to mir_wait_for,
- *                        or NULL if the interval could not be supported
- */
-MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surface, int interval)
-__attribute__((deprecated("Swap interval should be set on the backing content")));
-
-int mir_surface_get_dpi(MirSurface* surface)
-__attribute__((deprecated("use mir_window_get_dpi() instead")));
-
-MirSurfaceFocusState mir_surface_get_focus(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_focus_state() instead")));
-
-MirSurfaceVisibility mir_surface_get_visibility(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_visibility() instead")));
-
-MirWaitHandle* mir_surface_configure_cursor(MirSurface *surface, MirCursorConfiguration const* parameters)
-__attribute__((deprecated("use mir_window_configure_cursor() instead")));
-
-MirOrientation mir_surface_get_orientation(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_orientation() instead")));
-
 MirWaitHandle* mir_surface_set_preferred_orientation(MirSurface *surface, MirOrientationMode orientation)
 __attribute__((deprecated("use mir_window_set_preferred_orientation() instead")));
 
-MirOrientationMode mir_surface_get_preferred_orientation(MirSurface *surface)
-__attribute__((deprecated("use mir_window_get_preferred_orientation() instead")));
-
-MirWaitHandle* mir_surface_request_persistent_id(MirSurface* surface, mir_surface_id_callback callback, void* context)
-__attribute__((deprecated("use mir_window_request_persistent_id() instead")));
-
-MirPersistentId* mir_surface_request_persistent_id_sync(MirSurface *surface)
-__attribute__((deprecated("use mir_window_request_persistent_id_sync() instead")));
-
-void mir_surface_raise(MirSurface* surface, MirCookie const* cookie)
-__attribute__((deprecated("use mir_window_raise() instead")));
-
-#pragma GCC diagnostic pop
-
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/client/mir_toolkit/mir_window.h'
--- include/client/mir_toolkit/mir_window.h	2017-02-03 21:11:55 +0000
+++ include/client/mir_toolkit/mir_window.h	2017-02-07 00:07:50 +0000
@@ -781,7 +781,7 @@
  * \brief Request a persistent ID for a window and wait for the result
  * \param [in] window  The window to acquire a persistent ID for.
  * \return A MirWindowId. This MirWindowId is owned by the calling code, and must
- *         be freed with a call to mir_persistent_id_release()
+ *         be freed with a call to mir_window_id_release()
  */
 MirPersistentId* mir_window_request_persistent_id_sync(MirWindow* window)
 __attribute__((deprecated("Use mir_window_request_window_id_sync")));

=== modified file 'src/client/display_configuration_api.cpp'
--- src/client/display_configuration_api.cpp	2017-01-27 04:57:53 +0000
+++ src/client/display_configuration_api.cpp	2017-02-07 00:07:50 +0000
@@ -126,11 +126,6 @@
     return static_cast<MirOutputType>(output->type());
 }
 
-char const* mir_display_output_type_name(MirDisplayOutputType type)
-{
-    return mir::output_type_name(type);
-}
-
 char const* mir_output_type_name(MirOutputType type)
 {
     return mir::output_type_name(type);

=== modified file 'src/client/event.cpp'
--- src/client/event.cpp	2017-01-23 03:38:33 +0000
+++ src/client/event.cpp	2017-02-07 00:07:50 +0000
@@ -27,7 +27,6 @@
 #include "mir/events/event_private.h"
 #include "mir/events/surface_placement_event.h"
 
-#include "mir_toolkit/events/surface_event.h"
 #include "mir_toolkit/events/resize_event.h"
 #include "mir_toolkit/events/prompt_session_event.h"
 #include "mir_toolkit/events/orientation_event.h"
@@ -112,11 +111,6 @@
     return ev->to_input();
 })
 
-MirWindowEvent const* mir_event_get_surface_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    return mir_event_get_window_event(ev);
-})
-
 MirWindowEvent const* mir_event_get_window_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
     expect_event_type(ev, mir_event_type_window);
@@ -159,23 +153,6 @@
     return ev->to_keymap();
 })
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-
-    return ev->to_input_configuration();
-})
-#pragma GCC diagnostic pop
-
-MirWindowOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-
-    return mir_event_get_window_output_event(ev);
-})
-
 MirWindowOutputEvent const* mir_event_get_window_output_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
     expect_event_type(ev, mir_event_type_window_output);
@@ -190,21 +167,6 @@
     return ev->to_input_device_state();
 })
 
-/* Surface event accessors */
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    return static_cast<MirSurfaceAttrib>(mir_window_event_get_attribute(ev));
-})
-#pragma GCC diagnostic pop
-
-int mir_surface_event_get_attribute_value(MirWindowEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    return mir_window_event_get_attribute_value(ev);
-})
-
 /* Window event accessors */
 
 MirWindowAttrib mir_window_event_get_attribute(MirWindowEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
@@ -268,60 +230,6 @@
     return ev->device_id();
 })
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-/* Input configuration event accessors */
-MirInputConfigurationAction mir_input_configuration_event_get_action(MirInputConfigurationEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->action();
-})
-
-int64_t mir_input_configuration_event_get_time(MirInputConfigurationEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->when().count();
-})
-
-MirInputDeviceId mir_input_configuration_event_get_device_id(MirInputConfigurationEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_input_configuration);
-    return ev->id();
-})
-#pragma GCC diagnostic pop
-
-/* Surface output event accessors */
-
-int mir_surface_output_event_get_dpi(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-    return mir_window_output_event_get_dpi(ev);
-})
-
-MirFormFactor mir_surface_output_event_get_form_factor(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-    return mir_window_output_event_get_form_factor(ev);
-})
-
-float mir_surface_output_event_get_scale(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-    return mir_window_output_event_get_scale(ev);
-})
-
-double mir_surface_output_event_get_refresh_rate(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-    return mir_window_output_event_get_refresh_rate(ev);
-})
-
-uint32_t mir_surface_output_event_get_output_id(MirWindowOutputEvent const *ev) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    expect_event_type(ev, mir_event_type_window_output);
-    return mir_window_output_event_get_output_id(ev);
-})
-
 /* Window output event accessors */
 
 int mir_window_output_event_get_dpi(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
@@ -414,16 +322,6 @@
     return ev->device_pointer_buttons(index);
 })
 
-MirWindowPlacementEvent const* mir_event_get_surface_placement_event(MirEvent const* event) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    return mir_event_get_window_placement_event(event);
-})
-
-MirRectangle mir_surface_placement_get_relative_position(MirWindowPlacementEvent const* event) MIR_HANDLE_EVENT_EXCEPTION(
-{
-    return mir_window_placement_get_relative_position(event);
-})
-
 MirWindowPlacementEvent const* mir_event_get_window_placement_event(MirEvent const* event) MIR_HANDLE_EVENT_EXCEPTION(
 {
     return event->to_window_placement();

=== modified file 'src/client/event_printer.cpp'
--- src/client/event_printer.cpp	2017-01-19 05:30:03 +0000
+++ src/client/event_printer.cpp	2017-02-07 00:07:50 +0000
@@ -130,82 +130,6 @@
     }
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceAttrib attribute)
-{
-    switch (attribute)
-    {
-    PRINT(mir_surface_attrib,type);
-    PRINT(mir_surface_attrib,dpi);
-    PRINT(mir_surface_attrib,focus);
-    PRINT(mir_surface_attrib,state);
-    PRINT(mir_surface_attrib,visibility);
-    PRINT(mir_surface_attrib,swapinterval);
-    PRINT(mir_surface_attrib,preferred_orientation);
-    default:
-        return out << static_cast<int>(attribute) << "<INVALID>";
-    }
-}
-
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceFocusState state)
-{
-    switch (state)
-    {
-    PRINT(mir_surface,focused);
-    PRINT(mir_surface,unfocused);
-    default:
-        return out << static_cast<int>(state) << "<INVALID>";
-    }
-}
-
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceVisibility state)
-{
-    switch (state)
-    {
-    PRINT(mir_surface_visibility,exposed);
-    PRINT(mir_surface_visibility,occluded);
-    default:
-        return out << static_cast<int>(state) << "<INVALID>";
-    }
-}
-
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceType type)
-{
-    switch (type)
-    {
-    PRINT(mir_surface_type,normal);
-    PRINT(mir_surface_type,utility);
-    PRINT(mir_surface_type,dialog);
-    PRINT(mir_surface_type,gloss);
-    PRINT(mir_surface_type,freestyle);
-    PRINT(mir_surface_type,menu);
-    PRINT(mir_surface_type,inputmethod);
-    PRINT(mir_surface_type,satellite);
-    PRINT(mir_surface_type,tip);
-    default:
-        return out << static_cast<int>(type) << "<INVALID>";
-    }
-}
-
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceState state)
-{
-    switch (state)
-    {
-    PRINT(mir_surface_state,unknown);
-    PRINT(mir_surface_state,restored);
-    PRINT(mir_surface_state,minimized);
-    PRINT(mir_surface_state,maximized);
-    PRINT(mir_surface_state,vertmaximized);
-    PRINT(mir_surface_state,fullscreen);
-    PRINT(mir_surface_state,horizmaximized);
-    PRINT(mir_surface_state,hidden);
-    default:
-        return out << static_cast<int>(state) << "<INVALID>";
-    }
-}
-#pragma GCC diagnostic pop
-
 std::ostream& mir::operator<<(std::ostream& out, MirWindowAttrib attribute)
 {
     switch (attribute)
@@ -447,14 +371,12 @@
     auto type = mir_event_get_type(&event);
     switch (type)
     {
-        PRINT_EVENT(surface);
         PRINT_EVENT(resize);
         PRINT_EVENT(orientation);
         PRINT_EVENT(close_surface);
         PRINT_EVENT(input);
         PRINT_EVENT(input_device_state);
         PRINT_EVENT(keymap);
-        PRINT_EVENT(surface_placement);
     case mir_event_type_prompt_session_state_change:
         return out << *mir_event_get_prompt_session_event(&event);
     default:

=== modified file 'src/client/events/event_builders.cpp'
--- src/client/events/event_builders.cpp	2017-01-27 04:57:53 +0000
+++ src/client/events/event_builders.cpp	2017-02-07 00:07:50 +0000
@@ -85,20 +85,6 @@
     return make_uptr_event(e);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirSurfaceAttrib attribute, int value)
-{
-    auto e = new_event<MirSurfaceEvent>();
-
-    e->set_id(surface_id.as_value());
-    e->set_attrib(static_cast<MirWindowAttrib>(attribute));
-    e->set_value(value);
-
-    return make_uptr_event(e);
-}
-#pragma GCC diagnostic pop
-
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirWindowAttrib attribute, int value)
 {
     auto e = new_event<MirWindowEvent>();
@@ -202,22 +188,6 @@
     event.to_input()->to_pointer()->set_buttons(button_state);
 }
 
-// Deprecated version with uint64_t mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t /*mac*/, MirKeyboardAction action, xkb_keysym_t key_code,
-    int scan_code, MirInputEventModifiers modifiers)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, action, key_code, scan_code, modifiers);
-}
-
-// Deprecated version without mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirKeyboardAction action, xkb_keysym_t key_code,
-    int scan_code, MirInputEventModifiers modifiers)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, action, key_code, scan_code, modifiers);
-}
-
 mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
     std::vector<uint8_t> const& cookie, MirInputEventModifiers modifiers)
 {
@@ -231,20 +201,6 @@
     return make_uptr_event(e);
 }
 
-// Deprecated version with uint64_t mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t /*mac*/, MirInputEventModifiers modifiers)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers);
-}
-
-// Deprecated version without mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers);
-}
-
 void mev::add_touch(MirEvent &event, MirTouchId touch_id, MirTouchAction action,
     MirTouchTooltype tooltype, float x_axis_value, float y_axis_value,
     float pressure_value, float touch_major_value, float touch_minor_value, float)
@@ -275,54 +231,6 @@
     return make_uptr_event(e);
 }
 
-// Deprecated version with uint64_t mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t /*mac*/, MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value,
-    float relative_x_value, float relative_y_value)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers, action,
-                      buttons_pressed, x_axis_value, y_axis_value, hscroll_value,
-                      vscroll_value, relative_x_value, relative_y_value);
-}
-
-// Deprecated version without mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value,
-    float relative_x_value, float relative_y_value)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers, action,
-                      buttons_pressed, x_axis_value, y_axis_value, hscroll_value,
-                      vscroll_value, relative_x_value, relative_y_value);
-}
-
-// Deprecated version without relative axis
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    uint64_t /*mac*/, MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,                               
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers, action, buttons_pressed,
-                      x_axis_value, y_axis_value, hscroll_value, vscroll_value, 0, 0);
-}
-
-// Deprecated version without relative axis, and mac
-mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
-    MirInputEventModifiers modifiers, MirPointerAction action,
-    MirPointerButtons buttons_pressed,
-    float x_axis_value, float y_axis_value,
-    float hscroll_value, float vscroll_value)
-{
-    return make_event(device_id, timestamp, std::vector<uint8_t>{}, modifiers, action, buttons_pressed,
-                      x_axis_value, y_axis_value, hscroll_value, vscroll_value, 0, 0);
-}
-
 mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirInputDeviceId id, std::string const& model,
                                std::string const& layout, std::string const& variant, std::string const& options)
 {
@@ -345,20 +253,6 @@
     return ep;
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-mir::EventUPtr mev::make_event(MirInputConfigurationAction action, MirInputDeviceId id, std::chrono::nanoseconds time)
-{
-    auto e = new_event<MirInputConfigurationEvent>();
-
-    e->set_action(action);
-    e->set_when(time);
-    e->set_id(id);
-
-    return make_uptr_event(e);
-}
-#pragma GCC diagnostic pop
-
 mir::EventUPtr mev::make_event(std::chrono::nanoseconds timestamp,
                                MirPointerButtons pointer_buttons,
                                MirInputEventModifiers modifiers,

=== modified file 'src/client/mir_blob.cpp'
--- src/client/mir_blob.cpp	2017-01-18 02:29:37 +0000
+++ src/client/mir_blob.cpp	2017-02-07 00:07:50 +0000
@@ -61,73 +61,6 @@
 };
 }
 
-
-MirBlob* mir_blob_from_display_configuration(MirDisplayConfiguration* configuration)
-try
-{
-    mp::DisplayConfiguration protobuf_config;
-
-    for (auto const* card = configuration->cards; card != configuration->cards+configuration->num_cards; ++card)
-    {
-        auto protobuf_card = protobuf_config.add_display_card();
-        protobuf_card->set_card_id(card->card_id);
-        protobuf_card->set_max_simultaneous_outputs(card->max_simultaneous_outputs);
-    }
-
-    for (auto const* output = configuration->outputs;
-         output != configuration->outputs+configuration->num_outputs;
-         ++output)
-    {
-        auto protobuf_output = protobuf_config.add_display_output();
-
-        protobuf_output->set_output_id(output->output_id);
-        protobuf_output->set_card_id(output->card_id);
-        protobuf_output->set_type(output->type);
-
-        for (auto const* format = output->output_formats;
-             format != output->output_formats+output->num_output_formats;
-             ++format)
-        {
-            protobuf_output->add_pixel_format(*format);
-        }
-
-        for (auto const* mode = output->modes;
-             mode != output->modes+output->num_modes;
-             ++mode)
-        {
-            auto protobuf_output_mode = protobuf_output->add_mode();
-            protobuf_output_mode->set_horizontal_resolution(mode->horizontal_resolution);
-            protobuf_output_mode->set_vertical_resolution(mode->vertical_resolution);
-            protobuf_output_mode->set_refresh_rate(mode->refresh_rate);
-        }
-
-        protobuf_output->set_preferred_mode(output->preferred_mode);
-
-        protobuf_output->set_physical_width_mm(output->physical_width_mm);
-        protobuf_output->set_physical_height_mm(output->physical_height_mm);
-
-        protobuf_output->set_connected(output->connected);
-        protobuf_output->set_used(output->used);
-        protobuf_output->set_position_x(output->position_x);
-        protobuf_output->set_position_y(output->position_y);
-        protobuf_output->set_current_mode(output->current_mode);
-        protobuf_output->set_current_format(output->current_format);
-        protobuf_output->set_power_mode(output->power_mode);
-        protobuf_output->set_orientation(output->orientation);
-    }
-
-    auto blob = std::make_unique<MirManagedBlob>(static_cast<size_t>(protobuf_config.ByteSize()));
-
-    protobuf_config.SerializeWithCachedSizesToArray(blob->data());
-
-    return blob.release();
-}
-catch (std::exception const& x)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(x);
-    return nullptr;
-}
-
 MirBlob* mir_blob_from_display_config(MirDisplayConfig* configuration)
 try
 {
@@ -154,82 +87,6 @@
     return nullptr;
 }
 
-MirDisplayConfiguration* mir_blob_to_display_configuration(MirBlob* blob)
-try
-{
-    mp::DisplayConfiguration protobuf_config;
-
-    protobuf_config.ParseFromArray(mir_blob_data(blob), mir_blob_size(blob));
-
-    auto new_config = new MirDisplayConfiguration;
-
-    new_config->num_cards = protobuf_config.display_card_size();
-    new_config->cards = new MirDisplayCard[new_config->num_cards];
-
-    for (auto i = 0u; i != new_config->num_cards; ++i)
-    {
-        auto const& protobuf_card = protobuf_config.display_card(i);
-        auto& card = new_config->cards[i];
-        card.card_id = protobuf_card.card_id();
-        card.max_simultaneous_outputs = protobuf_card.max_simultaneous_outputs();
-    }
-
-    new_config->num_outputs = protobuf_config.display_output_size();
-    new_config->outputs = new MirDisplayOutput[new_config->num_outputs];
-
-    for (auto i = 0u; i != new_config->num_outputs; ++i)
-    {
-        auto const& protobuf_output = protobuf_config.display_output(i);
-        auto& output = new_config->outputs[i];
-
-        output.output_id = protobuf_output.output_id();
-        output.card_id = protobuf_output.card_id();
-        output.type = static_cast<MirDisplayOutputType>(protobuf_output.type());
-
-        output.num_output_formats = protobuf_output.pixel_format_size();
-        output.output_formats = new MirPixelFormat[output.num_output_formats];
-
-        output.num_modes = protobuf_output.mode_size();
-        output.modes = new MirDisplayMode[output.num_modes];
-
-        for (auto i = 0u; i != output.num_output_formats; ++i)
-        {
-            output.output_formats[i] = static_cast<MirPixelFormat>(protobuf_output.pixel_format(i));
-        }
-
-        for (auto i = 0u; i != output.num_modes; ++i)
-        {
-            auto const& protobuf_mode = protobuf_output.mode(i);
-            auto& mode = output.modes[i];
-
-            mode.horizontal_resolution = protobuf_mode.horizontal_resolution();
-            mode.vertical_resolution = protobuf_mode.vertical_resolution();
-            mode.refresh_rate = protobuf_mode.refresh_rate();
-        }
-
-        output.preferred_mode = protobuf_output.preferred_mode();
-
-        output.physical_width_mm = protobuf_output.physical_width_mm();
-        output.physical_height_mm = protobuf_output.physical_height_mm();
-
-        output.connected = protobuf_output.connected();
-        output.used = protobuf_output.used();
-        output.position_x = protobuf_output.position_x();
-        output.position_y = protobuf_output.position_y();
-        output.current_mode = protobuf_output.current_mode();
-        output.current_format = static_cast<MirPixelFormat>(protobuf_output.current_format());
-        output.orientation = static_cast<MirOrientation>(protobuf_output.orientation());
-        output.power_mode = static_cast<MirPowerMode>(protobuf_output.power_mode());
-    }
-
-    return new_config;
-}
-catch (std::exception const& x)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(x);
-    abort();
-}
-
 MirDisplayConfig* mir_blob_to_display_config(MirBlob* blob)
 try
 {

=== modified file 'src/client/mir_connection_api.cpp'
--- src/client/mir_connection_api.cpp	2017-01-24 19:42:48 +0000
+++ src/client/mir_connection_api.cpp	2017-02-07 00:07:50 +0000
@@ -139,26 +139,6 @@
     MIR_LOG_UNCAUGHT_EXCEPTION(ex);
 }
 
-void mir_connection_get_platform(
-    MirConnection* connection,
-    MirPlatformPackage* platform_package)
-{
-    connection->populate(*platform_package);
-}
-
-void mir_connection_get_graphics_module(MirConnection *connection, MirModuleProperties *properties)
-try
-{
-    mir::require(mir_connection_is_valid(connection));
-    mir::require(properties != nullptr);
-
-    connection->populate_graphics_module(*properties);
-}
-catch (std::exception const& ex)
-{
-    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-}
-
 void mir_connection_set_lifecycle_event_callback(
     MirConnection* connection,
     MirLifecycleEventCallback callback,
@@ -381,22 +361,6 @@
         connection->available_surface_formats(formats, format_size, *num_valid_formats);
 }
 
-MirWaitHandle* mir_connection_platform_operation(
-    MirConnection* connection,
-    MirPlatformMessage const* request,
-    MirPlatformOperationCallback callback, void* context)
-{
-    try
-    {
-        return connection->platform_operation(request, callback, context);
-    }
-    catch (std::exception const& ex)
-    {
-        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-        return nullptr;
-    }
-}
-
 void mir_connection_set_error_callback(
     MirConnection* connection,
     MirErrorCallback callback,

=== modified file 'src/client/mir_debug_api.cpp'
--- src/client/mir_debug_api.cpp	2017-01-18 04:43:15 +0000
+++ src/client/mir_debug_api.cpp	2017-02-07 00:07:50 +0000
@@ -30,25 +30,3 @@
 {
     return window->get_buffer_stream()->get_current_buffer_id();
 }
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-bool mir_debug_surface_coords_to_screen(MirSurface* surface,
-                                       int x, int y,
-                                       int* screen_x, int* screen_y)
-{
-    return surface->translate_to_screen_coordinates(x, y, screen_x, screen_y);
-}
-
-uint32_t mir_debug_surface_current_buffer_id(MirSurface* surface)
-{
-    return mir_debug_window_current_buffer_id(surface);
-}
-
-int mir_debug_surface_id(MirSurface* surface)
-{
-    return mir_debug_window_id(surface);
-}
-
-#pragma GCC diagnostic pop

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2017-02-02 22:43:06 +0000
+++ src/client/mir_surface.cpp	2017-02-07 00:07:50 +0000
@@ -525,8 +525,8 @@
          * mir_window_output_event_get_refresh_rate that tells us the full
          * native speed of the most relevant output...
          */
-        auto soevent = mir_event_get_surface_output_event(&e);
-        auto rate = mir_surface_output_event_get_refresh_rate(soevent);
+        auto soevent = mir_event_get_window_output_event(&e);
+        auto rate = mir_window_output_event_get_refresh_rate(soevent);
         if (rate > 10.0)  // should be >0, but 10 to workaround LP: #1639725
         {
             std::chrono::nanoseconds const ns(

=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2017-02-03 21:11:55 +0000
+++ src/client/mir_surface_api.cpp	2017-02-07 00:07:50 +0000
@@ -832,6 +832,7 @@
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 void mir_window_spec_add_render_surface(
     MirWindowSpec* spec,
     MirRenderSurface* render_surface,
@@ -860,291 +861,6 @@
     MIR_LOG_UNCAUGHT_EXCEPTION(ex);
 }
 
-MirSurfaceSpec* mir_connection_create_spec_for_normal_surface(MirConnection* connection,
-                                                              int width, int height,
-                                                              MirPixelFormat format)
-{
-    auto spec = mir_create_normal_window_spec(connection, width, height);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_menu(MirConnection* connection,
-                                                    int width, int height,
-                                                    MirPixelFormat format,
-                                                    MirSurface* parent,
-                                                    MirRectangle* rect,
-                                                    MirEdgeAttachment edge)
-{
-    auto spec = mir_create_menu_window_spec(connection, width, height, parent, rect, edge);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_tooltip(MirConnection* connection,
-                                                       int width, int height,
-                                                       MirPixelFormat format,
-                                                       MirSurface* parent,
-                                                       MirRectangle* rect)
-{
-    auto spec = mir_create_tip_window_spec(connection, width, height, parent, rect, mir_edge_attachment_any);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_tip(MirConnection* connection,
-                                                   int width, int height,
-                                                   MirPixelFormat format,
-                                                   MirSurface* parent,
-                                                   MirRectangle* rect,
-                                                   MirEdgeAttachment edge)
-{
-    auto spec = mir_create_tip_window_spec(connection, width, height, parent, rect, edge);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_dialog(MirConnection* connection,
-                                                      int width, int height,
-                                                      MirPixelFormat format)
-{
-    auto spec = mir_create_dialog_window_spec(connection, width, height);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_input_method(MirConnection* connection,
-                                                            int width, int height,
-                                                            MirPixelFormat format)
-{
-    auto spec = mir_create_input_method_window_spec(connection, width, height);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_modal_dialog(MirConnection* connection,
-                                                            int width, int height,
-                                                            MirPixelFormat format,
-                                                            MirSurface* parent)
-{
-    auto spec = mir_create_modal_dialog_window_spec(connection, width, height, parent);
-    mir_window_spec_set_pixel_format(spec, format);
-    return spec;
-}
-
-MirSurface* mir_surface_create_sync(MirSurfaceSpec* requested_specification)
-{
-    return mir_create_window_sync(requested_specification);
-}
-
-MirWaitHandle* mir_surface_create(MirSurfaceSpec* requested_specification,
-                                  mir_surface_callback callback, void* context)
-{
-    return window_create_helper(requested_specification, callback, context);
-}
-
-void mir_surface_spec_set_name(MirSurfaceSpec* spec, char const* name)
-{
-    mir_window_spec_set_name(spec, name);
-}
-
-void mir_surface_spec_set_width(MirSurfaceSpec* spec, unsigned width)
-{
-    mir_window_spec_set_width(spec, width);
-}
-
-void mir_surface_spec_set_height(MirSurfaceSpec* spec, unsigned height)
-{
-    mir_window_spec_set_height(spec, height);
-}
-
-void mir_surface_spec_set_min_width(MirSurfaceSpec* spec, unsigned min_width)
-{
-    mir_window_spec_set_min_width(spec, min_width);
-}
-
-void mir_surface_spec_set_min_height(MirSurfaceSpec* spec, unsigned min_height)
-{
-    mir_window_spec_set_min_height(spec, min_height);
-}
-
-void mir_surface_spec_set_max_width(MirSurfaceSpec* spec, unsigned max_width)
-{
-    mir_window_spec_set_max_width(spec, max_width);
-}
-
-void mir_surface_spec_set_max_height(MirSurfaceSpec* spec, unsigned max_height)
-{
-    mir_window_spec_set_max_height(spec, max_height);
-}
-
-void mir_surface_spec_set_pixel_format(MirSurfaceSpec* spec, MirPixelFormat format)
-{
-    mir_window_spec_set_pixel_format(spec, format);
-}
-
-void mir_surface_spec_set_buffer_usage(MirSurfaceSpec* spec, MirBufferUsage usage)
-{
-    mir_window_spec_set_buffer_usage(spec, usage);
-}
-
-void mir_surface_spec_set_state(MirSurfaceSpec* spec, MirSurfaceState state)
-{
-    mir_window_spec_set_state(spec, static_cast<MirWindowState>(state));
-}
-
-void mir_surface_spec_set_fullscreen_on_output(MirSurfaceSpec* spec, uint32_t output_id)
-{
-    mir_window_spec_set_fullscreen_on_output(spec, output_id);
-}
-
-void mir_surface_spec_set_preferred_orientation(MirSurfaceSpec* spec, MirOrientationMode mode)
-{
-    mir_window_spec_set_preferred_orientation(spec, mode);
-}
-
-void mir_surface_spec_set_event_handler(MirSurfaceSpec* spec,
-                                        mir_surface_event_callback callback,
-                                        void* context)
-{
-    mir_window_spec_set_event_handler(spec, callback, context);
-}
-
-void mir_surface_spec_set_shell_chrome(MirSurfaceSpec* spec, MirShellChrome style)
-{
-    mir_window_spec_set_shell_chrome(spec, style);
-}
-
-void mir_surface_spec_release(MirSurfaceSpec* spec)
-{
-    mir_window_spec_release(spec);
-}
-
-MirSurfaceSpec* mir_create_surface_spec(MirConnection* connection)
-{
-    return mir_create_window_spec(connection);
-}
-
-MirSurfaceSpec* mir_connection_create_spec_for_changes(MirConnection* connection)
-{
-    return mir_create_window_spec(connection);
-}
-
-void mir_surface_apply_spec(MirSurface* surface, MirSurfaceSpec* spec)
-{
-    mir_window_apply_spec(surface, spec);
-}
-
-void mir_surface_spec_set_streams(MirSurfaceSpec* spec, MirBufferStreamInfo* streams, unsigned int size)
-{
-    mir_window_spec_set_streams(spec, streams, size);
-}
-
-void mir_surface_spec_set_input_shape(MirSurfaceSpec *spec, MirRectangle const* rectangles,
-                                      size_t n_rects)
-{
-    mir_window_spec_set_input_shape(spec, rectangles, n_rects);
-}
-
-void mir_surface_spec_set_parent(MirSurfaceSpec* spec, MirSurface* parent)
-{
-    mir_window_spec_set_parent(spec, parent);
-}
-
-void mir_surface_spec_set_type(MirSurfaceSpec* spec, MirSurfaceType type)
-{
-    mir_window_spec_set_type(spec, static_cast<MirWindowType>(type));
-}
-
-void mir_surface_spec_set_width_increment(MirSurfaceSpec* spec, unsigned width_inc)
-{
-    mir_window_spec_set_width_increment(spec, width_inc);
-}
-
-void mir_surface_spec_set_height_increment(MirSurfaceSpec* spec, unsigned height_inc)
-{
-    mir_window_spec_set_height_increment(spec, height_inc);
-}
-
-void mir_surface_spec_set_min_aspect_ratio(MirSurfaceSpec* spec, unsigned width, unsigned height)
-{
-    mir_window_spec_set_min_aspect_ratio(spec, width, height);
-}
-
-void mir_surface_spec_set_max_aspect_ratio(MirSurfaceSpec* spec, unsigned width, unsigned height)
-{
-    mir_window_spec_set_max_aspect_ratio(spec, width, height);
-}
-
-void mir_surface_spec_set_pointer_confinement(MirSurfaceSpec* spec, MirPointerConfinementState state)
-{
-    mir_window_spec_set_pointer_confinement(spec, state);
-}
-
-void mir_surface_spec_set_placement(MirSurfaceSpec* spec,
-                                    MirRectangle const* rect,
-                                    MirPlacementGravity rect_gravity,
-                                    MirPlacementGravity window_gravity,
-                                    MirPlacementHints placement_hints,
-                                    int offset_dx, int offset_dy)
-{
-    mir_window_spec_set_placement(spec,
-                                  rect,
-                                  rect_gravity,
-                                  window_gravity,
-                                  placement_hints,
-                                  offset_dx,
-                                  offset_dy);
-}
-
-bool mir_surface_spec_attach_to_foreign_parent(MirSurfaceSpec* spec,
-                                               MirWindowId* parent,
-                                               MirRectangle* attachment_rect,
-                                               MirEdgeAttachment edge)
-{
-    return mir_window_spec_attach_to_foreign_parent(spec,
-                                                    parent,
-                                                    attachment_rect,
-                                                    edge);
-}
-
-void mir_surface_set_event_handler(MirSurface* surface, mir_surface_event_callback callback, void* context)
-{
-    mir_window_set_event_handler(surface, callback, context);
-}
-
-bool mir_surface_is_valid(MirSurface* surface)
-{
-    return mir_window_is_valid(surface);
-}
-
-char const* mir_surface_get_error_message(MirSurface* surface)
-{
-    return mir_window_get_error_message(surface);
-}
-
-void mir_surface_get_parameters(MirSurface* surface, MirSurfaceParameters* parameters)
-{
-    mir_window_get_parameters(surface, parameters);
-}
-
-MirWaitHandle* mir_surface_release(
-    MirSurface* surface,
-    mir_surface_callback callback, void* context)
-{
-    return window_release_helper(surface, callback, context);
-}
-
-void mir_surface_release_sync(MirSurface* surface)
-{
-    mir_window_release_sync(surface);
-}
-
-MirSurfaceType mir_surface_get_type(MirSurface* surf)
-{
-    return static_cast<MirSurfaceType>(mir_window_get_type(surf));
-}
-
 MirWaitHandle* mir_surface_set_state(MirSurface* surf, MirSurfaceState state)
 try
 {
@@ -1162,77 +878,6 @@
     return static_cast<MirSurfaceState>(mir_window_get_state(surf));
 }
 
-MirOrientation mir_surface_get_orientation(MirSurface *surface)
-{
-    return mir_window_get_orientation(surface);
-}
-
-MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surf, int interval)
-{
-    if (interval < 0)
-        return nullptr;
-
-    try
-    {
-        if (surf)
-        {
-            if (auto stream = surf->get_buffer_stream())
-                return stream->set_swap_interval(interval);
-        }
-    }
-    catch (std::exception const& ex)
-    {
-        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-        return nullptr;
-    }
-    return nullptr;
-}
-
-int mir_surface_get_swapinterval(MirSurface* surf)
-{
-    int swap_interval = -1;
-
-    try
-    {
-        if (surf)
-        {
-            if (auto stream = surf->get_buffer_stream())
-                swap_interval = stream->swap_interval();
-        }
-    }
-    catch (std::exception const& ex)
-    {
-        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
-    }
-
-    return swap_interval;
-}
-
-int mir_surface_get_dpi(MirSurface* surf)
-{
-    return mir_window_get_dpi(surf);
-}
-
-MirSurfaceFocusState mir_surface_get_focus(MirSurface* surf)
-{
-    return static_cast<MirSurfaceFocusState>(mir_window_get_focus_state(surf));
-}
-
-MirSurfaceVisibility mir_surface_get_visibility(MirSurface* surf)
-{
-    return static_cast<MirSurfaceVisibility>(mir_window_get_visibility(surf));
-}
-
-MirWaitHandle* mir_surface_configure_cursor(MirSurface* surface, MirCursorConfiguration const* cursor)
-{
-    return mir_configure_cursor_helper(surface, cursor);
-}
-
-MirOrientationMode mir_surface_get_preferred_orientation(MirSurface *surf)
-{
-    return mir_window_get_preferred_orientation(surf);
-}
-
 MirWaitHandle* mir_surface_set_preferred_orientation(MirSurface *surf, MirOrientationMode mode)
 try
 {
@@ -1245,51 +890,8 @@
     return nullptr;
 }
 
-void mir_surface_raise(MirSurface* surf, MirCookie const* cookie)
-{
-    mir_window_raise(surf, cookie);
-}
-
-MirBufferStream* mir_surface_get_buffer_stream(MirSurface *surface)
-{
-    return mir_window_get_buffer_stream(surface);
-}
-
-MirWaitHandle* mir_surface_request_persistent_id(MirSurface* surface, MirWindowIdCallback callback, void* context)
-{
-    return mir_window_request_persistent_id_helper(surface, callback, context);
-}
-
-MirWindowId* mir_surface_request_persistent_id_sync(MirSurface *surface)
-{
-    MirWindowId* result = nullptr;
-    if (auto wh = mir_window_request_persistent_id_helper(surface, &assign_surface_id_result, &result))
-        wh->wait_for_all();
-    return result;
-}
-
 #pragma GCC diagnostic pop
 
-bool mir_persistent_id_is_valid(MirWindowId* id)
-{
-    return mir_window_id_is_valid(id);
-}
-
-void mir_persistent_id_release(MirWindowId* id)
-{
-    mir_window_id_release(id);
-}
-
-char const* mir_persistent_id_as_string(MirWindowId *id)
-{
-    return mir_window_id_as_string(id);
-}
-
-MirWindowId* mir_persistent_id_from_string(char const* id_string)
-{
-    return mir_window_id_from_string(id_string);
-}
-
 bool mir_window_id_is_valid(MirWindowId* id)
 {
     return id != nullptr;

=== modified file 'src/client/symbols-debug.map'
--- src/client/symbols-debug.map	2015-06-17 05:20:42 +0000
+++ src/client/symbols-debug.map	2017-02-07 00:07:50 +0000
@@ -1,4 +1,4 @@
-MIR_CLIENT_DEBUG_9 {
+MIR_CLIENT_DEBUG_1_0 {
  global: 
    mir_debug_*;
  local: *;

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2017-02-02 19:17:46 +0000
+++ src/client/symbols.map	2017-02-07 00:07:50 +0000
@@ -21,24 +21,15 @@
     mir_connection_create_display_config;
     mir_connection_create_prompt_session_sync;
     mir_connection_create_screencast_sync;
-    mir_connection_create_spec_for_changes;
-    mir_connection_create_spec_for_dialog;
     mir_connection_create_spec_for_input_method;
-    mir_connection_create_spec_for_menu;
-    mir_connection_create_spec_for_modal_dialog;
-    mir_connection_create_spec_for_normal_surface;
-    mir_connection_create_spec_for_tooltip;
     mir_connection_get_available_surface_formats;
     mir_connection_get_egl_native_display;
     mir_connection_get_error_message;
-    mir_connection_get_platform;
     mir_connection_is_valid;
-    mir_connection_platform_operation;
     mir_connection_release;
     mir_connection_set_display_config_change_callback;
     mir_connection_set_lifecycle_event_callback;
     mir_connect_sync;
-    mir_create_surface_spec;
     mir_cursor_configuration_destroy;
     mir_cursor_configuration_from_buffer_stream;
     mir_cursor_configuration_from_name;
@@ -48,21 +39,16 @@
     mir_disabled_cursor_name;
     mir_display_config_destroy;
     mir_event_get_close_surface_event;
-    mir_event_get_input_configuration_event;
     mir_event_get_input_event;
     mir_event_get_keymap_event;
     mir_event_get_orientation_event;
     mir_event_get_prompt_session_event;
     mir_event_get_resize_event;
-    mir_event_get_surface_event;
     mir_event_get_type;
     mir_event_ref;
     mir_event_unref;
     mir_horizontal_resize_cursor_name;
     mir_hsplit_resize_cursor_name;
-    mir_input_configuration_event_get_action;
-    mir_input_configuration_event_get_device_id;
-    mir_input_configuration_event_get_time;
     mir_input_event_get_device_id;
     mir_input_event_get_event_time;
     mir_input_event_get_keyboard_event;
@@ -73,12 +59,9 @@
     mir_keyboard_event_key_code;
     mir_keyboard_event_modifiers;
     mir_keyboard_event_scan_code;
-    mir_keymap_event_get_rules;
     mir_omnidirectional_resize_cursor_name;
     mir_open_hand_cursor_name;
     mir_orientation_event_get_direction;
-    mir_persistent_id_is_valid;
-    mir_persistent_id_release;
     mir_platform_message_create;
     mir_platform_message_get_data;
     mir_platform_message_get_fds;
@@ -101,53 +84,6 @@
     mir_resize_event_get_width;
     mir_screencast_get_buffer_stream;
     mir_screencast_release_sync;
-    mir_surface_apply_spec;
-    mir_surface_configure_cursor;
-    mir_surface_create;
-    mir_surface_create_sync;
-    mir_surface_event_get_attribute;
-    mir_surface_event_get_attribute_value;
-    mir_surface_get_buffer_stream;
-    mir_surface_get_dpi;
-    mir_surface_get_error_message;
-    mir_surface_get_focus;
-    mir_surface_get_orientation;
-    mir_surface_get_parameters;
-    mir_surface_get_preferred_orientation;
-    mir_surface_get_state;
-    mir_surface_get_swapinterval;
-    mir_surface_get_type;
-    mir_surface_get_visibility;
-    mir_surface_is_valid;
-    mir_surface_release;
-    mir_surface_release_sync;
-    mir_surface_request_persistent_id;
-    mir_surface_request_persistent_id_sync;
-    mir_surface_set_event_handler;
-    mir_surface_set_preferred_orientation;
-    mir_surface_set_state;
-    mir_surface_set_swapinterval;
-    mir_surface_spec_release;
-    mir_surface_spec_set_buffer_usage;
-    mir_surface_spec_set_fullscreen_on_output;
-    mir_surface_spec_set_height;
-    mir_surface_spec_set_height_increment;
-    mir_surface_spec_set_max_aspect_ratio;
-    mir_surface_spec_set_max_height;
-    mir_surface_spec_set_max_width;
-    mir_surface_spec_set_min_aspect_ratio;
-    mir_surface_spec_set_min_height;
-    mir_surface_spec_set_min_width;
-    mir_surface_spec_set_name;
-    mir_surface_spec_set_parent;
-    mir_surface_spec_set_pixel_format;
-    mir_surface_spec_set_placement;
-    mir_surface_spec_set_preferred_orientation;
-    mir_surface_spec_set_state;
-    mir_surface_spec_set_streams;
-    mir_surface_spec_set_type;
-    mir_surface_spec_set_width;
-    mir_surface_spec_set_width_increment;
     mir_touch_event_action;
     mir_touch_event_axis_value;
     mir_touch_event_id;
@@ -158,6 +94,9 @@
     mir_vsplit_resize_cursor_name;
     mir_wait_for;
     mir_wait_for_one;
+    mir_surface_set_state;
+    mir_surface_get_state;
+    mir_surface_set_preferred_orientation;
  local: *;
 };
 
@@ -167,42 +106,25 @@
     mir_connection_set_ping_event_callback;
     mir_crosshair_cursor_name;
     mir_keyboard_event_input_event;
-    mir_persistent_id_as_string;
-    mir_persistent_id_from_string;
     mir_pointer_event_input_event;
     mir_touch_event_input_event;
-    mir_surface_spec_attach_to_foreign_parent;
-    mir_surface_spec_set_input_shape;
     mir_connection_get_egl_pixel_format;
   local: *;
 } MIR_CLIENT_9;
 
-MIR_CLIENT_9.2 {  # New functions in Mir 0.16
-  global:
-    mir_surface_spec_set_event_handler;
-  local: *;
-} MIR_CLIENT_9.1;
-
 MIR_CLIENT_9v17 {
-    mir_blob_from_display_configuration;
     mir_blob_size;
     mir_blob_data;
     mir_blob_release;
     mir_blob_onto_buffer;
-    mir_blob_to_display_configuration;
     mir_blob_release;
     mir_buffer_stream_set_scale;
     mir_buffer_stream_set_scale_sync;
-    mir_event_get_surface_output_event;
-    mir_surface_output_event_get_dpi;
-    mir_surface_output_event_get_form_factor;
-    mir_surface_output_event_get_scale;
-} MIR_CLIENT_9.2;
+} MIR_CLIENT_9.1;
 
 MIR_CLIENT_9v18 {
   global:
     mir_buffer_stream_get_error_message;
-    mir_surface_output_event_get_output_id;
     mir_connection_set_base_display_config;
   local:
     *;
@@ -210,8 +132,6 @@
 
 MIR_CLIENT_9v19 {
   global:
-    mir_connection_get_graphics_module;
-    mir_surface_raise;
     mir_input_event_has_cookie;
     mir_cookie_buffer_size;
     mir_input_event_get_cookie;
@@ -220,7 +140,6 @@
     mir_cookie_release;
     mir_keymap_event_get_keymap_buffer;
     mir_keymap_event_get_device_id;
-    mir_surface_spec_set_shell_chrome;
 } MIR_CLIENT_9v18;
 
 MIR_CLIENT_0.21 {
@@ -413,13 +332,10 @@
     mir_input_device_state_event_pointer_buttons;
     mir_input_device_state_event_time;
     mir_input_device_state_event_device_pointer_buttons;
-    mir_surface_spec_set_pointer_confinement;
 } MIR_CLIENT_0.22;
 
 MIR_CLIENT_0.25 {  # New functions in Mir 0.25
   global:
-    mir_connection_create_spec_for_tip;
-    mir_event_get_surface_placement_event;
     mir_output_get_current_mode_index;
     mir_output_get_preferred_mode_index;
     mir_output_get_subpixel_arrangement;
@@ -428,10 +344,7 @@
     mir_output_get_gamma;
     mir_output_set_gamma;
     mir_connection_cancel_base_display_configuration_preview;
-    mir_surface_placement_get_relative_position;
-    mir_display_output_type_name;
     mir_output_type_name;
-    mir_surface_output_event_get_refresh_rate;
     mir_input_device_state_event_device_pressed_keys_for_index;
     mir_buffer_stream_set_swapinterval;
     mir_buffer_stream_get_swapinterval;

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2017-02-01 17:43:59 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2017-02-07 00:07:50 +0000
@@ -42,7 +42,6 @@
   test_server_startup.cpp
   test_debug_api.cpp
   test_unresponsive_client.cpp
-  test_client_platform_operation.cpp
   test_input_device_hub.cpp
   test_latency.cpp
   test_render_override.cpp

=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2017-02-03 22:37:56 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2017-02-07 00:07:50 +0000
@@ -787,26 +787,6 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, accesses_platform_package)
-{
-    using namespace testing;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
-#pragma GCC diagnostic pop
-
-    MirPlatformPackage platform_package;
-    ::memset(&platform_package, -1, sizeof(platform_package));
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    mir_connection_get_platform(connection, &platform_package);
-#pragma GCC diagnostic pop
-    EXPECT_THAT(platform_package, mtf::IsStubPlatformPackage());
-
-    mir_connection_release(connection);
-}
-
 TEST_F(ClientLibrary, accesses_display_info)
 {
 #pragma GCC diagnostic push
@@ -1120,9 +1100,7 @@
     mir_connection_release(connection);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(ClientLibrary, can_get_persistent_surface_id)
+TEST_F(ClientLibrary, can_get_window_id)
 {
     auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -1133,11 +1111,11 @@
 
     ASSERT_THAT(window, IsValid());
 
-    auto surface_id = mir_window_request_persistent_id_sync(window);
-    EXPECT_TRUE(mir_persistent_id_is_valid(surface_id));
+    auto surface_id = mir_window_request_window_id_sync(window);
+    EXPECT_TRUE(mir_window_id_is_valid(surface_id));
 
     mir_window_release_sync(window);
-    mir_persistent_id_release(surface_id);
+    mir_window_id_release(surface_id);
     mir_connection_release(connection);
 }
 
@@ -1152,11 +1130,11 @@
 
     ASSERT_THAT(main_surface, IsValid());
 
-    auto main_surface_id = mir_window_request_persistent_id_sync(main_surface);
-    ASSERT_TRUE(mir_persistent_id_is_valid(main_surface_id));
+    auto main_surface_id = mir_window_request_window_id_sync(main_surface);
+    ASSERT_TRUE(mir_window_id_is_valid(main_surface_id));
 
     // Serialise & deserialise the ID
-    auto im_parent_id = mir_persistent_id_from_string(mir_persistent_id_as_string(main_surface_id));
+    auto im_parent_id = mir_window_id_from_string(mir_window_id_as_string(main_surface_id));
 
     auto im_client = mir_connect_sync(new_connection().c_str(), "IM Client");
     surface_spec = mir_create_input_method_window_spec(im_client, 200, 20);
@@ -1176,14 +1154,13 @@
     EXPECT_THAT(im_surface, IsValid());
 
     mir_window_spec_release(surface_spec);
-    mir_persistent_id_release(main_surface_id);
-    mir_persistent_id_release(im_parent_id);
+    mir_window_id_release(main_surface_id);
+    mir_window_id_release(im_parent_id);
     mir_window_release_sync(main_surface);
     mir_window_release_sync(im_surface);
     mir_connection_release(first_client);
     mir_connection_release(im_client);
 }
-#pragma GCC diagnostic pop
 
 //lp:1661704
 TEST_F(ClientLibrary, can_get_window_id_more_than_once_in_quick_succession)

=== modified file 'tests/acceptance-tests/test_client_library_callbacks.cpp'
--- tests/acceptance-tests/test_client_library_callbacks.cpp	2017-01-18 16:58:17 +0000
+++ tests/acceptance-tests/test_client_library_callbacks.cpp	2017-02-07 00:07:50 +0000
@@ -125,31 +125,6 @@
         3s);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(ClientLibraryCallbacks, create_surface_callback_is_called_before_wait_handler_has_result)
-{
-    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-
-    auto const spec = mir_create_normal_window_spec(connection, 100, 100);
-    mir_window_spec_set_pixel_format(spec, mir_pixel_format_argb_8888);
-    auto const wh = mir_surface_create(spec, create_surface_callback, this);
-    mir_window_spec_release(spec);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    mir_wait_for(wh);
-#pragma GCC diagnostic pop
-
-    EXPECT_THAT(window.load(), NotNull());
-
-    // Even if the test fails, wait for object to become ready so we can
-    // tear down properly
-    mt::spin_wait_for_condition_or_timeout(
-        [this] { return window != nullptr; },
-        3s);
-}
-#pragma GCC diagnostic pop
-
 TEST_F(ClientLibraryCallbacks, swap_buffers_callback_is_called_before_wait_handler_has_result)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
@@ -170,26 +145,3 @@
         [this] { return buffers == 1; },
         3s);
 }
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(ClientLibraryCallbacks, release_surface_callback_is_called_before_wait_handler_has_result)
-{
-    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    window = mtf::make_any_surface(connection);
-
-    auto const wh = mir_surface_release(window, release_surface_callback, this);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    mir_wait_for(wh);
-#pragma GCC diagnostic pop
-
-    EXPECT_THAT(window.load(), IsNull());
-
-    // Even if the test fails, wait for object to become ready so we can
-    // tear down properly
-    mt::spin_wait_for_condition_or_timeout(
-        [this] { return window == nullptr; },
-        3s);
-}
-#pragma GCC diagnostic pop

=== modified file 'tests/acceptance-tests/test_client_library_errors.cpp'
--- tests/acceptance-tests/test_client_library_errors.cpp	2017-02-01 19:54:40 +0000
+++ tests/acceptance-tests/test_client_library_errors.cpp	2017-02-07 00:07:50 +0000
@@ -206,9 +206,7 @@
     mir_connection_release(connection);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(ClientLibraryErrors, passing_invalid_parent_id_to_surface_create)
+TEST_F(ClientLibraryErrors, passing_invalid_parent_id_to_window_create)
 {
     using namespace testing;
 
@@ -217,7 +215,7 @@
     ASSERT_THAT(connection, IsValid());
 
     // An ID that parses as valid, but doesn't correspond to any
-    auto invalid_id = mir_persistent_id_from_string("05f223a2-39e5-48b9-9416-b0ce837351b6");
+    auto invalid_id = mir_window_id_from_string("05f223a2-39e5-48b9-9416-b0ce837351b6");
 
     auto spec = mir_create_input_method_window_spec(connection, 200, 200);
     mir_window_spec_set_pixel_format(spec, mir_pixel_format_argb_8888);
@@ -233,7 +231,7 @@
     EXPECT_THAT(window, Not(IsValid()));
     EXPECT_THAT(mir_window_get_error_message(window), MatchesRegex(".*Lookup.*failed.*"));
 
-    mir_persistent_id_release(invalid_id);
+    mir_window_id_release(invalid_id);
     mir_window_spec_release(spec);
     mir_window_release_sync(window);
     mir_connection_release(connection);
@@ -241,7 +239,6 @@
 
 using ClientLibraryErrorsDeathTest = ClientLibraryErrors;
 
-
 TEST_F(ClientLibraryErrorsDeathTest, creating_surface_on_garbage_connection_is_fatal)
 {
     auto connection = mir_connect_sync("garbage", __PRETTY_FUNCTION__);
@@ -296,7 +293,7 @@
     auto spec = mir_create_input_method_window_spec(connection, 100, 100);
     mir_window_spec_set_pixel_format(spec, mir_pixel_format_argb_8888);
 
-    auto id = mir_persistent_id_from_string("fa69b2e9-d507-4005-be61-5068f40a5aec");
+    auto id = mir_window_id_from_string("fa69b2e9-d507-4005-be61-5068f40a5aec");
 
     MIR_EXPECT_DEATH(
     {
@@ -304,11 +301,10 @@
                                                   mir_edge_attachment_any);
     }, "");
 
-    mir_persistent_id_release(id);
+    mir_window_id_release(id);
     mir_connection_release(connection);
 }
 
-#pragma GCC diagnostic pop
 TEST_F(ClientLibraryErrorsDeathTest, creating_screencast_with_invalid_connection)
 {
     MIR_EXPECT_DEATH(mir_create_screencast_spec(nullptr), "");

=== removed file 'tests/acceptance-tests/test_client_platform_operation.cpp'
--- tests/acceptance-tests/test_client_platform_operation.cpp	2017-01-18 16:58:17 +0000
+++ tests/acceptance-tests/test_client_platform_operation.cpp	1970-01-01 00:00:00 +0000
@@ -1,198 +0,0 @@
-#include "mir_toolkit/mir_client_library.h"
-#include "mir_test_framework/connected_client_headless_server.h"
-#include "mir_test_framework/stub_graphics_platform_operation.h"
-#include "mir/test/pipe.h"
-
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include <cstring>
-#include <unistd.h>
-
-//whole test should be removed once the platform messages are removed
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-namespace mtf = mir_test_framework;
-
-namespace
-{
-
-void assign_reply(MirConnection*, MirPlatformMessage* reply, void* context)
-{
-    auto message = static_cast<MirPlatformMessage**>(context);
-    *message = reply;
-}
-
-struct ClientPlatformOperation : mtf::ConnectedClientHeadlessServer
-{
-    MirPlatformMessage* platform_operation_add(int num1, int num2)
-    {
-        return platform_operation_add({num1,num2});
-    }
-
-    MirPlatformMessage* incorrect_platform_operation_add()
-    {
-        return platform_operation_add({7});
-    }
-
-    MirPlatformMessage* platform_operation_add(std::vector<int> const& nums)
-    {
-        auto const request = mir_platform_message_create(add_opcode);
-        mir_platform_message_set_data(request, nums.data(), sizeof(int) * nums.size());
-        MirPlatformMessage* reply;
-
-        auto const platform_op_done = mir_connection_platform_operation(
-            connection, request, assign_reply, &reply);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-        mir_wait_for(platform_op_done);
-#pragma GCC diagnostic pop
-
-        mir_platform_message_release(request);
-
-        return reply;
-    }
-
-    MirPlatformMessage* platform_operation_echo_fd(int fd)
-    {
-        unsigned int const echo_fd_opcode =
-            static_cast<unsigned int>(mtf::StubGraphicsPlatformOperation::echo_fd);
-
-        auto const request = mir_platform_message_create(echo_fd_opcode);
-        mir_platform_message_set_fds(request, &fd, 1);
-        MirPlatformMessage* reply;
-
-        auto const platform_op_done = mir_connection_platform_operation(
-                connection, request, assign_reply, &reply);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-        mir_wait_for(platform_op_done);
-#pragma GCC diagnostic pop
-
-        mir_platform_message_release(request);
-
-        return reply;
-    }
-
-    unsigned int const add_opcode =
-        static_cast<unsigned int>(mtf::StubGraphicsPlatformOperation::add);
-};
-
-MATCHER_P(MessageDataAsIntsEq, v, "")
-{
-    using namespace testing;
-    auto msg_data = mir_platform_message_get_data(arg);
-    if (msg_data.size % sizeof(int) != 0)
-        throw std::runtime_error("Data is not an array of ints");
-
-    std::vector<int> data(msg_data.size / sizeof(int));
-    memcpy(data.data(), msg_data.data, msg_data.size);
-
-    return v == data;
-}
-
-MATCHER(MessageDataIsEmpty, "")
-{
-    auto const msg_data = mir_platform_message_get_data(arg);
-    return msg_data.size == 0 && msg_data.data == nullptr;
-}
-
-MATCHER_P(MessageOpcodeEq, opcode, "")
-{
-    auto const msg_opcode = mir_platform_message_get_opcode(arg);
-    return msg_opcode == opcode;
-}
-
-MATCHER(MessageFdsIsEmpty, "")
-{
-    auto const msg_fds = mir_platform_message_get_fds(arg);
-    return msg_fds.num_fds == 0 && msg_fds.fds == nullptr;
-}
-
-}
-
-TEST_F(ClientPlatformOperation, exchanges_data_items_with_platform)
-{
-    using namespace testing;
-
-    int const num1 = 7;
-    int const num2 = 11;
-
-    auto const reply = platform_operation_add(num1, num2);
-
-    EXPECT_THAT(reply, MessageDataAsIntsEq(std::vector<int>{num1 + num2}));
-
-    mir_platform_message_release(reply);
-}
-
-TEST_F(ClientPlatformOperation, does_not_set_connection_error_message_on_success)
-{
-    using namespace testing;
-
-    auto const reply = platform_operation_add(7, 11);
-
-    EXPECT_THAT(mir_connection_get_error_message(connection), StrEq(""));
-
-    mir_platform_message_release(reply);
-}
-
-TEST_F(ClientPlatformOperation, reply_has_opcode_of_request)
-{
-    using namespace testing;
-
-    auto const reply = platform_operation_add(7, 11);
-
-    EXPECT_THAT(reply, MessageOpcodeEq(add_opcode));
-
-    mir_platform_message_release(reply);
-}
-
-TEST_F(ClientPlatformOperation, returns_empty_reply_on_error)
-{
-    using namespace testing;
-
-    auto const reply = incorrect_platform_operation_add();
-
-    EXPECT_THAT(reply, MessageDataIsEmpty());
-    EXPECT_THAT(reply, MessageFdsIsEmpty());
-
-    mir_platform_message_release(reply);
-}
-
-TEST_F(ClientPlatformOperation, sets_connection_error_message_on_error)
-{
-    using namespace testing;
-
-    auto const reply = incorrect_platform_operation_add();
-
-    EXPECT_THAT(mir_connection_get_error_message(connection), StrNe(""));
-
-    mir_platform_message_release(reply);
-}
-
-TEST_F(ClientPlatformOperation, exchanges_fd_items_with_platform)
-{
-    using namespace testing;
-
-    char const sent_char{'#'};
-
-    mir::test::Pipe pipe;
-    EXPECT_THAT(write(pipe.write_fd(), &sent_char, 1), Eq(1));
-
-    auto const reply = platform_operation_echo_fd(pipe.read_fd());
-    EXPECT_THAT(reply, MessageDataIsEmpty());
-
-    auto const reply_fds = mir_platform_message_get_fds(reply);
-    EXPECT_THAT(reply_fds.num_fds, Eq(1u));
-
-    auto const reply_fd = reply_fds.fds[0];
-    EXPECT_THAT(reply_fd, Ne(pipe.read_fd()));
-
-    char reply_char{0};
-    EXPECT_THAT(read(reply_fd, &reply_char, 1), Eq(1));
-    EXPECT_THAT(reply_char, Eq(sent_char));
-
-    close(reply_fd);
-    mir_platform_message_release(reply);
-}
-#pragma GCC diagnostic pop

=== modified file 'tests/acceptance-tests/test_client_surfaces.cpp'
--- tests/acceptance-tests/test_client_surfaces.cpp	2017-02-01 19:54:40 +0000
+++ tests/acceptance-tests/test_client_surfaces.cpp	2017-02-07 00:07:50 +0000
@@ -281,8 +281,6 @@
     mir_window_release_sync(window);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 TEST_F(ClientSurfaces, input_methods_get_corret_parent_coordinates)
 {
     using namespace testing;
@@ -313,7 +311,7 @@
 
     auto window = mtf::make_any_surface(connection);
 
-    auto parent_id = mir_window_request_persistent_id_sync(window);
+    auto parent_id = mir_window_request_window_id_sync(window);
 
     auto im_connection = mir_connect_sync(new_connection().c_str(), "Mock IM connection");
     ASSERT_THAT(im_connection, IsValid());
@@ -324,7 +322,7 @@
 
     mir_window_spec_attach_to_foreign_parent(spec, parent_id, &client_rect, edge_attachment);
 
-    mir_persistent_id_release(parent_id);
+    mir_window_id_release(parent_id);
 
     auto im = mir_create_window_sync(spec);
     mir_window_spec_release(spec);
@@ -334,4 +332,3 @@
 
     mir_connection_release(im_connection);
 }
-#pragma GCC diagnostic pop

=== modified file 'tests/acceptance-tests/test_debug_api.cpp'
--- tests/acceptance-tests/test_debug_api.cpp	2017-01-18 02:29:37 +0000
+++ tests/acceptance-tests/test_debug_api.cpp	2017-02-07 00:07:50 +0000
@@ -149,88 +149,6 @@
 };
 }
 
-TEST_F(DebugAPI, translates_surface_coordinates_to_screen_coordinates_deprecated)
-{
-    start_server_with_debug(true);
-
-    mir::geometry::Rectangle surface_location{{200, 100}, {800, 600}};
-
-    set_surface_placement(surface_location);
-
-    auto window = mtf::make_any_surface(connection);
-    ASSERT_TRUE(mir_window_is_valid(window));
-
-    int screen_x, screen_y, x, y;
-    x = 35, y = 21;
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    ASSERT_TRUE(mir_debug_surface_coords_to_screen(window, x, y, &screen_x, &screen_y));
-#pragma GCC diagnostic pop
-    EXPECT_EQ(x + surface_location.top_left.x.as_int(), screen_x);
-    EXPECT_EQ(y + surface_location.top_left.y.as_int(), screen_y);
-
-    mir_window_release_sync(window);
-
-    surface_location.top_left = {100, 250};
-
-    set_surface_placement(surface_location);
-
-    window = mtf::make_any_surface(connection);
-    ASSERT_TRUE(mir_window_is_valid(window));
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    ASSERT_TRUE(mir_debug_surface_coords_to_screen(window, x, y, &screen_x, &screen_y));
-#pragma GCC diagnostic pop
-    EXPECT_EQ(x + surface_location.top_left.x.as_int(), screen_x);
-    EXPECT_EQ(y + surface_location.top_left.y.as_int(), screen_y);
-
-    mir_window_release_sync(window);
-}
-
-TEST_F(DebugAPI, is_unavailable_when_server_not_started_with_debug_deprecated)
-{
-    start_server_with_debug(false);
-
-    auto window = mtf::make_any_surface(connection);
-    ASSERT_TRUE(mir_window_is_valid(window));
-
-    int screen_x, screen_y;
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    EXPECT_FALSE(mir_debug_surface_coords_to_screen(window, 0, 0, &screen_x, &screen_y));
-#pragma GCC diagnostic pop
-
-    mir_window_release_sync(window);
-}
-
-TEST_F(DebugAPI, is_overrideable_deprecated)
-{
-    server.override_the_coordinate_translator([&]()
-        ->std::shared_ptr<mir::scene::CoordinateTranslator>
-        {
-            return std::make_shared<SimpleCoordinateTranslator>();
-        });
-
-    start_server_with_debug(false);
-
-    auto window = mtf::make_any_surface(connection);
-    ASSERT_TRUE(mir_window_is_valid(window));
-
-    int screen_x, screen_y;
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    EXPECT_TRUE(mir_debug_surface_coords_to_screen(window, 0, 0, &screen_x, &screen_y));
-#pragma GCC diagnostic pop
-    EXPECT_EQ(testpoint.x.as_int(), screen_x);
-    EXPECT_EQ(testpoint.y.as_int(), screen_y);
-
-    mir_window_release_sync(window);
-}
-
 TEST_F(DebugAPI, translates_surface_coordinates_to_screen_coordinates)
 {
     start_server_with_debug(true);

=== modified file 'tests/acceptance-tests/test_mirblob.cpp'
--- tests/acceptance-tests/test_mirblob.cpp	2017-01-18 13:59:18 +0000
+++ tests/acceptance-tests/test_mirblob.cpp	2017-02-07 00:07:50 +0000
@@ -30,36 +30,6 @@
 using MirBlobAPI = mir_test_framework::ConnectedClientWithASurface;
 using mir::test::DisplayConfigMatches;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(MirBlobAPI, can_serialize_display_configuration)
-{
-    std::vector<uint8_t> buffer;
-
-    auto const save_display_config = mir_connection_create_display_config(connection);
-
-    {
-        auto const save_blob = mir_blob_from_display_configuration(save_display_config);
-
-        buffer.resize(mir_blob_size(save_blob));
-        memcpy(buffer.data(), mir_blob_data(save_blob), buffer.size());
-        mir_blob_release(save_blob);
-    }
-
-    MirDisplayConfiguration* restore_display_config;
-    {
-        auto const restore_blob = mir_blob_onto_buffer(buffer.data(), buffer.size());
-        restore_display_config = mir_blob_to_display_configuration(restore_blob);
-        mir_blob_release(restore_blob);
-    }
-
-    EXPECT_THAT(save_display_config, DisplayConfigMatches(restore_display_config));
-
-    mir_display_config_destroy(restore_display_config);
-    mir_display_config_destroy(save_display_config);
-}
-#pragma GCC diagnostic pop
-
 TEST_F(MirBlobAPI, can_serialize_display_config)
 {
     std::vector<uint8_t> buffer;

=== modified file 'tests/acceptance-tests/test_persistent_surface_store.cpp'
--- tests/acceptance-tests/test_persistent_surface_store.cpp	2017-02-01 19:54:40 +0000
+++ tests/acceptance-tests/test_persistent_surface_store.cpp	2017-02-07 00:07:50 +0000
@@ -68,9 +68,7 @@
 };
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-TEST_F(TestPersistentSurfaceStore, server_and_client_persistent_id_matches)
+TEST_F(TestPersistentSurfaceStore, server_and_client_window_id_matches)
 {
     auto const shell_server_surface = latest_shell_surface();
     ASSERT_THAT(shell_server_surface, NotNull());
@@ -78,10 +76,9 @@
     MirPersistentId* client_surface_id = mir_window_request_persistent_id_sync(window);
     msh::PersistentSurfaceStore::Id server_surface_id = server.the_persistent_surface_store()->id_for_surface(shell_server_surface);
 
-    std::string client_surface_id_string(mir_persistent_id_as_string(client_surface_id));
+    std::string client_surface_id_string(mir_window_id_as_string(client_surface_id));
 
     ASSERT_THAT(server_surface_id.serialize_to_string(), Eq(client_surface_id_string));
 
-    mir_persistent_id_release(client_surface_id);
+    mir_window_id_release(client_surface_id);
 }
-#pragma GCC diagnostic pop