Merge lp:~mir-team/miral/miral-0.26 into lp:miral/release

[Cemil Azizoglu]

Adaptations for Mir 0.26.

Adaptations for Mir 0.26.

[Alan Griffiths (alan-griffiths)]

review: Approve

[Alan Griffiths (alan-griffiths)]

The hack for generating backward-compatible synonyms fails to account for the case of building against earlier versions of Mir. In which case it fails to generate forward-compatible synonyms.

That is, MirAL 1.1 built against Mir 0.25 is not ABI compatible with MirAL 1.1 built against Mir 0.26.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

> The hack for generating backward-compatible synonyms fails to account for the
> case of building against earlier versions of Mir. In which case it fails to
> generate forward-compatible synonyms.
>
> That is, MirAL 1.1 built against Mir 0.25 is not ABI compatible with MirAL 1.1
> built against Mir 0.26.

I've an MP against lp:miral that addresses this. My preference would be to land that (and anything else that's been approved) and re-sync this release branch.

[Alan Griffiths (alan-griffiths)]

LGTM now

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-01-18 18:15:55 +0000
+++ CMakeLists.txt	2017-01-26 16:46:42 +0000
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.1)
 project(miral)
 
 if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
@@ -16,16 +16,20 @@
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED on)
+set(CMAKE_CXX_EXTENSIONS off)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED on)
+set(CMAKE_C_EXTENSIONS off)
+
 set(MIRAL_COMPILER_FLAGS "-pthread -g -Werror -Wall -pedantic -Wextra -fPIC")
 set(MIRAL_LINKER_FLAGS   "-Wl,-z,defs")
 
-check_cxx_compiler_flag(-Wno-mismatched-tags MIRAL_COMPILE_WITH_W_NO_MISMATCHED_TAGS)
-if (MIRAL_COMPILE_WITH_W_NO_MISMATCHED_TAGS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-mismatched-tags")
-endif()
-
 set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} ${MIRAL_COMPILER_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MIRAL_COMPILER_FLAGS} -Wnon-virtual-dtor -std=c++14")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MIRAL_COMPILER_FLAGS} -Wnon-virtual-dtor")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-long-long") # fix spurious FTBFS on X+O
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MIRAL_LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MIRAL_LINKER_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS} ${MIRAL_LINKER_FLAGS}")
@@ -37,8 +41,8 @@
 include_directories(include SYSTEM ${MIRCLIENT_INCLUDE_DIRS})
 
 set(MIRAL_VERSION_MAJOR 1)
-set(MIRAL_VERSION_MINOR 0)
-set(MIRAL_VERSION_PATCH 2)
+set(MIRAL_VERSION_MINOR 1)
+set(MIRAL_VERSION_PATCH 0)
 
 set(MIRAL_VERSION ${MIRAL_VERSION_MAJOR}.${MIRAL_VERSION_MINOR}.${MIRAL_VERSION_PATCH})
 

=== modified file 'debian/changelog'
--- debian/changelog	2017-01-18 18:17:47 +0000
+++ debian/changelog	2017-01-26 16:46:42 +0000
@@ -1,3 +1,20 @@
+miral (1.1.0) UNRELEASED; urgency=medium
+
+  * New upstream release 1.1.0 (https://launchpad.net/miral/+milestone/1.1)
+    - ABI summary:
+      . miral ABI unchanged at 2
+    - Enhancements:
+      . Compatibility with Mir 0.26 and update API to use the new Mir types and
+        enums.
+      . Logging of exceptions added to --window-management-trace
+      . Rename WindowManagementPolicy::place_new_surface => place_new_window"
+    - Bugs fixed:
+      . top-level window is not raised along with its child (LP: #1658085)
+      . miral-shell depends on default cursor theme being installed
+        (LP: #1658159)
+
+ -- Alan Griffiths <[e-mail]>  Wed, 14 Dec 2016 16:31:08 +0000
+
 miral (1.0.2+17.04.20170118.1-0ubuntu1) zesty; urgency=medium
 
   * New upstream release 1.0.1 (https://launchpad.net/miral/+milestone/1.0)

=== modified file 'debian/control'
--- debian/control	2016-12-20 15:45:29 +0000
+++ debian/control	2017-01-26 16:46:42 +0000
@@ -63,6 +63,7 @@
 Architecture: linux-any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+Recommends: dmz-cursor-theme,
 Description: Display server for Ubuntu - demonstration programs
  MirAL provides an ABI-stable abstraction layer for Mir based shells,
  insulating them from mirserver ABI breaks.

=== modified file 'debian/libmiral2.symbols'
--- debian/libmiral2.symbols	2016-12-13 13:07:15 +0000
+++ debian/libmiral2.symbols	2017-01-26 16:46:42 +0000
@@ -354,4 +354,11 @@
  (c++)"typeinfo for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
  (c++)"vtable for miral::ActiveOutputsListener@MIRAL_1.0" 1.0.0
  (c++)"vtable for miral::WindowManagementPolicy@MIRAL_1.0" 1.0.0
- (c++)"vtable for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
\ No newline at end of file
+ (c++)"vtable for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
+ MIRAL_1.1@MIRAL_1.1 1.1.0
+ (c++)"miral::WindowInfo::needs_titlebar(MirWindowType)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::type(MirWindowType)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::state(MirWindowState)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowManagementPolicy::advise_state_change(miral::WindowInfo const&, MirWindowState)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::can_morph_to(MirWindowType) const@MIRAL_1.1" 1.1.0
+ (c++)"miral::CanonicalWindowManagerPolicy::place_new_window(miral::ApplicationInfo const&, miral::WindowSpecification const&)@MIRAL_1.1" 1.1.0
\ No newline at end of file

=== modified file 'include/miral/canonical_window_manager.h'
--- include/miral/canonical_window_manager.h	2016-12-05 09:46:35 +0000
+++ include/miral/canonical_window_manager.h	2017-01-26 16:46:42 +0000
@@ -31,8 +31,7 @@
 
     explicit CanonicalWindowManagerPolicy(WindowManagerTools const& tools);
 
-    /// places the surfaces as requested
-    auto place_new_surface(
+    auto place_new_window(
         ApplicationInfo const& app_info,
         WindowSpecification const& request_parameters)
         -> WindowSpecification override;

=== modified file 'include/miral/detail/mir_forward_compatibility.h'
--- include/miral/detail/mir_forward_compatibility.h	2016-09-23 13:59:34 +0000
+++ include/miral/detail/mir_forward_compatibility.h	2017-01-26 16:46:42 +0000
@@ -20,8 +20,50 @@
 #define MIRAL_MIR_FORWARD_COMPATIBILITY_H
 
 #include <mir_toolkit/version.h>
+#include <mir_toolkit/common.h>
 #include <miral/detail/mir_features.h>
 
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+using MirWindowAttrib = MirSurfaceAttrib;
+auto const mir_window_attrib_type                    = mir_surface_attrib_type;
+auto const mir_window_attrib_state                   = mir_surface_attrib_state;
+auto const mir_window_attrib_swapinterval            = mir_surface_attrib_swapinterval;
+auto const mir_window_attrib_focus                   = mir_surface_attrib_focus;
+auto const mir_window_attrib_dpi                     = mir_surface_attrib_dpi;
+auto const mir_window_attrib_visibility              = mir_surface_attrib_visibility;
+auto const mir_window_attrib_preferred_orientation   = mir_surface_attrib_preferred_orientation;
+auto const mir_window_attribs                        = mir_surface_attribs;
+
+using MirWindowType = MirSurfaceType;
+auto const mir_window_type_normal        = mir_surface_type_normal;
+auto const mir_window_type_utility       = mir_surface_type_utility;
+auto const mir_window_type_dialog        = mir_surface_type_dialog;
+auto const mir_window_type_gloss         = mir_surface_type_gloss;
+auto const mir_window_type_freestyle     = mir_surface_type_freestyle;
+auto const mir_window_type_menu          = mir_surface_type_menu;
+auto const mir_window_type_inputmethod   = mir_surface_type_inputmethod;
+auto const mir_window_type_satellite     = mir_surface_type_satellite;
+auto const mir_window_type_tip           = mir_surface_type_tip;
+auto const mir_window_types              = mir_surface_types;
+
+using MirWindowState = MirSurfaceState;
+auto const mir_window_state_unknown          = mir_surface_state_unknown;
+auto const mir_window_state_restored         = mir_surface_state_restored;
+auto const mir_window_state_minimized        = mir_surface_state_minimized;
+auto const mir_window_state_maximized        = mir_surface_state_maximized;
+auto const mir_window_state_vertmaximized    = mir_surface_state_vertmaximized;
+auto const mir_window_state_fullscreen       = mir_surface_state_fullscreen;
+auto const mir_window_state_horizmaximized   = mir_surface_state_horizmaximized;
+auto const mir_window_state_hidden           = mir_surface_state_hidden;
+auto const mir_window_states                 = mir_surface_states;
+
+typedef struct MirSurface MirWindow;
+typedef struct MirSurfaceParameters MirWindowParameters;
+typedef struct MirSurfacePlacementEvent MirWindowPlacementEvent;
+typedef struct MirSurfaceSpec MirWindowSpec;
+#endif
+
+
 // Types that don't exist in earlier versions of Mir's toolkit
 #if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 4, 0)
 

=== modified file 'include/miral/toolkit/persistent_id.h'
--- include/miral/toolkit/persistent_id.h	2016-08-11 10:53:11 +0000
+++ include/miral/toolkit/persistent_id.h	2017-01-26 16:46:42 +0000
@@ -19,7 +19,13 @@
 #ifndef MIRAL_TOOLKIT_PERSISTENT_ID_H
 #define MIRAL_TOOLKIT_PERSISTENT_ID_H
 
+#include <miral/detail/mir_forward_compatibility.h>
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
 #include <mir_toolkit/mir_surface.h>
+#else
+#include <mir_toolkit/mir_window.h>
+#include <mir_toolkit/mir_persistent_id.h>
+#endif
 
 #include <memory>
 
@@ -32,7 +38,11 @@
 {
 public:
     explicit PersistentId(MirPersistentId* id) : self{id, deleter} {}
-    explicit PersistentId(MirSurface* surface) : PersistentId{mir_surface_request_persistent_id_sync(surface)} {}
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+    explicit PersistentId(MirWindow* surface) : PersistentId{mir_surface_request_persistent_id_sync(surface)} {}
+#else
+    explicit PersistentId(MirWindow* surface) : PersistentId{mir_window_request_persistent_id_sync(surface)} {}
+#endif
 
     auto c_str() const -> char const* { return mir_persistent_id_as_string(self.get()); }
 

=== renamed file 'include/miral/toolkit/surface.h' => 'include/miral/toolkit/window.h'
--- include/miral/toolkit/surface.h	2016-09-13 17:09:04 +0000
+++ include/miral/toolkit/window.h	2017-01-26 16:46:42 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2016 Canonical Ltd.
+ * Copyright © 2016-2017 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,10 +16,17 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#ifndef MIRAL_TOOLKIT_SURFACE_H
-#define MIRAL_TOOLKIT_SURFACE_H
-
+#ifndef MIRAL_TOOLKIT_WINDOW_H
+#define MIRAL_TOOLKIT_WINDOW_H
+
+#include <miral/detail/mir_forward_compatibility.h>
+
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
 #include <mir_toolkit/mir_surface.h>
+auto const mir_window_release_sync = mir_surface_release_sync;
+#else
+#include <mir_toolkit/mir_window.h>
+#endif
 
 #include <memory>
 
@@ -27,23 +34,23 @@
 {
 namespace toolkit
 {
-/// Handle class for MirSurface - provides automatic reference counting.
-class Surface
+/// Handle class for MirWindow - provides automatic reference counting.
+class Window
 {
 public:
-    Surface() = default;
-    explicit Surface(MirSurface* spec) : self{spec, deleter} {}
-
-
-    operator MirSurface*() const { return self.get(); }
+    Window() = default;
+    explicit Window(MirWindow* spec) : self{spec, deleter} {}
+
+
+    operator MirWindow*() const { return self.get(); }
 
     void reset() { self.reset(); }
 
 private:
-    static void deleter(MirSurface* surface) { mir_surface_release_sync(surface); }
-    std::shared_ptr<MirSurface> self;
+    static void deleter(MirWindow* window) { mir_window_release_sync(window); }
+    std::shared_ptr<MirWindow> self;
 };
 }
 }
 
-#endif //MIRAL_TOOLKIT_SURFACE_H
+#endif //MIRAL_TOOLKIT_WINDOW_H

=== renamed file 'include/miral/toolkit/surface_spec.h' => 'include/miral/toolkit/window_spec.h'
--- include/miral/toolkit/surface_spec.h	2016-11-30 08:22:39 +0000
+++ include/miral/toolkit/window_spec.h	2017-01-26 16:46:42 +0000
@@ -16,10 +16,11 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#ifndef MIRAL_TOOLKIT_SURFACE_SPEC_H
-#define MIRAL_TOOLKIT_SURFACE_SPEC_H
+#ifndef MIRAL_TOOLKIT_WINDOW_SPEC_H
+#define MIRAL_TOOLKIT_WINDOW_SPEC_H
 
-#include <miral/toolkit/surface.h>
+#include <miral/toolkit/window.h>
+#include <miral/detail/mir_forward_compatibility.h>
 
 #include <mir_toolkit/mir_surface.h>
 #include <mir_toolkit/mir_connection.h>
@@ -31,26 +32,38 @@
 {
 namespace toolkit
 {
-/// Handle class for MirSurfaceSpec - provides automatic reference counting, method chaining.
-class SurfaceSpec
+/// Handle class for MirWindowSpec - provides automatic reference counting, method chaining.
+class WindowSpec
 {
 public:
-    explicit SurfaceSpec(MirSurfaceSpec* spec) : self{spec, deleter} {}
+    explicit WindowSpec(MirWindowSpec* spec) : self{spec, deleter} {}
 
-    static auto for_normal_surface(MirConnection* connection, int width, int height, MirPixelFormat format) -> SurfaceSpec
+    static auto for_normal_surface(MirConnection* connection, int width, int height, MirPixelFormat format) -> WindowSpec
     {
-        return SurfaceSpec{mir_connection_create_spec_for_normal_surface(connection, width, height, format)};
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return WindowSpec{mir_connection_create_spec_for_normal_surface(connection, width, height, format)};
+#else
+        auto spec = WindowSpec{mir_create_normal_window_spec(connection, width, height)};
+        mir_window_spec_set_pixel_format(spec, format);
+        return spec;
+#endif
     }
 
     static auto for_menu(MirConnection* connection,
                          int width,
                          int height,
                          MirPixelFormat format,
-                         MirSurface* parent,
+                         MirWindow* parent,
                          MirRectangle* rect,
-                         MirEdgeAttachment edge) -> SurfaceSpec
+                         MirEdgeAttachment edge) -> WindowSpec
     {
-        return SurfaceSpec{mir_connection_create_spec_for_menu(connection, width, height, format, parent, rect, edge)};
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return WindowSpec{mir_connection_create_spec_for_menu(connection, width, height, format, parent, rect, edge)};
+#else
+        auto spec = WindowSpec{mir_create_menu_window_spec(connection, width, height, parent, rect, edge)};
+        mir_window_spec_set_pixel_format(spec, format);
+        return spec;
+#endif
     }
 
 #if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
@@ -58,87 +71,143 @@
                         int width,
                         int height,
                         MirPixelFormat format,
-                        MirSurface* parent,
+                        MirWindow* parent,
                         MirRectangle* rect,
-                        MirEdgeAttachment edge) -> SurfaceSpec
+                        MirEdgeAttachment edge) -> WindowSpec
     {
-        return SurfaceSpec{mir_connection_create_spec_for_tip(connection, width, height, format, parent, rect, edge)};
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return WindowSpec{mir_connection_create_spec_for_tip(connection, width, height, format, parent, rect, edge)};
+#else
+        auto spec = WindowSpec{mir_create_tip_window_spec(connection, width, height, parent, rect, edge)};
+        mir_window_spec_set_pixel_format(spec, format);
+        return spec;
+#endif
     }
 #endif
 
     static auto for_dialog(MirConnection* connection,
                            int width,
                            int height,
-                           MirPixelFormat format)-> SurfaceSpec
+                           MirPixelFormat format)-> WindowSpec
     {
-        return SurfaceSpec{mir_connection_create_spec_for_dialog(connection, width, height, format)};
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return WindowSpec{mir_connection_create_spec_for_dialog(connection, width, height, format)};
+#else
+        auto spec = WindowSpec{mir_create_dialog_window_spec(connection, width, height)};
+        mir_window_spec_set_pixel_format(spec, format);
+        return spec;
+#endif
     }
 
     static auto for_dialog(MirConnection* connection,
                            int width,
                            int height,
                            MirPixelFormat format,
-                           MirSurface* parent) -> SurfaceSpec
+                           MirWindow* parent) -> WindowSpec
     {
         return for_dialog(connection, width, height, format).set_parent(parent);
     }
 
-    static auto for_changes(MirConnection* connection) -> SurfaceSpec
+    static auto for_changes(MirConnection* connection) -> WindowSpec
     {
-        return SurfaceSpec{mir_connection_create_spec_for_changes(connection)};
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return WindowSpec{mir_connection_create_spec_for_changes(connection)};
+#else
+        return WindowSpec{mir_create_window_spec(connection)};
+#endif
     }
 
-    auto set_buffer_usage(MirBufferUsage usage) -> SurfaceSpec&
+    auto set_buffer_usage(MirBufferUsage usage) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_buffer_usage(*this, usage);
+#else
+        mir_window_spec_set_buffer_usage(*this, usage);
+#endif
         return *this;
     }
 
-    auto set_type(MirSurfaceType type) -> SurfaceSpec&
+    auto set_type(MirWindowType type) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_type(*this, type);
+#else
+        mir_window_spec_set_type(*this, type);
+#endif
         return *this;
     }
 
-    auto set_min_size(int min_width, int min_height) -> SurfaceSpec&
+    auto set_min_size(int min_width, int min_height) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_min_width(*this, min_width);
         mir_surface_spec_set_min_height(*this, min_height);
+#else
+        mir_window_spec_set_min_width(*this, min_width);
+        mir_window_spec_set_min_height(*this, min_height);
+#endif
         return *this;
     }
 
-    auto set_max_size(int max_width, int max_height) -> SurfaceSpec&
+    auto set_max_size(int max_width, int max_height) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_max_width(*this, max_width);
         mir_surface_spec_set_max_height(*this, max_height);
+#else
+        mir_window_spec_set_max_width(*this, max_width);
+        mir_window_spec_set_max_height(*this, max_height);
+#endif
         return *this;
     }
 
-    auto set_size_inc(int width_inc, int height_inc) -> SurfaceSpec&
+    auto set_size_inc(int width_inc, int height_inc) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_width_increment(*this, width_inc);
         mir_surface_spec_set_height_increment(*this, height_inc);
+#else
+        mir_window_spec_set_width_increment(*this, width_inc);
+        mir_window_spec_set_height_increment(*this, height_inc);
+#endif
         return *this;
     }
 
-    auto set_size(int width, int height) -> SurfaceSpec&
+    auto set_size(int width, int height) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_width(*this, width);
         mir_surface_spec_set_height(*this, height);
+#else
+        mir_window_spec_set_width(*this, width);
+        mir_window_spec_set_height(*this, height);
+#endif
         return *this;
     }
 
-    auto set_name(char const* name) -> SurfaceSpec&
+    auto set_name(char const* name) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_name(*this, name);
+#else
+        mir_window_spec_set_name(*this, name);
+#endif
         return *this;
     }
 
-    auto set_event_handler(mir_surface_event_callback callback, void* context) -> SurfaceSpec&
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+    auto set_event_handler(mir_surface_event_callback callback, void* context) -> WindowSpec&
     {
         mir_surface_spec_set_event_handler(*this, callback, context);
         return *this;
     }
+#else
+    auto set_event_handler(MirWindowEventCallback callback, void* context) -> WindowSpec&
+    {
+        mir_window_spec_set_event_handler(*this, callback, context);
+        return *this;
+    }
+#endif
 
 #if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
     auto set_placement(const MirRectangle* rect,
@@ -146,42 +215,66 @@
                        MirPlacementGravity surface_gravity,
                        MirPlacementHints   placement_hints,
                        int                 offset_dx,
-                       int                 offset_dy) -> SurfaceSpec&
+                       int                 offset_dy) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_placement(*this, rect, rect_gravity, surface_gravity, placement_hints, offset_dx, offset_dy);
+#else
+        mir_window_spec_set_placement(*this, rect, rect_gravity, surface_gravity, placement_hints, offset_dx, offset_dy);
+#endif
         return *this;
     }
 #endif
 
-    auto set_parent(MirSurface* parent) -> SurfaceSpec&
+    auto set_parent(MirWindow* parent) -> WindowSpec&
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_spec_set_parent(*this, parent);
+#else
+        mir_window_spec_set_parent(*this, parent);
+#endif
         return *this;
     }
 
     template<typename Context>
-    void create_surface(void (*callback)(MirSurface*, Context*), Context* context) const
+    void create_surface(void (*callback)(MirWindow*, Context*), Context* context) const
     {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_create(*this, reinterpret_cast<mir_surface_callback>(callback), context);
-    }
-
-    auto create_surface() const -> Surface
-    {
-        return Surface{mir_surface_create_sync(*this)};
-    }
-
-    void apply_to(MirSurface* surface) const
-    {
+#else
+        mir_create_window(*this, reinterpret_cast<MirWindowCallback>(callback), context);
+#endif
+    }
+
+    auto create_surface() const -> Window
+    {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+        return Window{mir_surface_create_sync(*this)};
+#else
+        return Window{mir_create_window_sync(*this)};
+#endif
+    }
+
+    void apply_to(MirWindow* surface) const
+    {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_apply_spec(surface, *this);
+#else
+        mir_window_apply_spec(surface, *this);
+#endif
     }
 
-    operator MirSurfaceSpec*() const { return self.get(); }
+    operator MirWindowSpec*() const { return self.get(); }
 
 private:
-    static void deleter(MirSurfaceSpec* spec) { mir_surface_spec_release(spec); }
-    std::shared_ptr<MirSurfaceSpec> self;
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
+    static void deleter(MirWindowSpec* spec) { mir_surface_spec_release(spec); }
+#else
+    static void deleter(MirWindowSpec* spec) { mir_window_spec_release(spec); }
+#endif
+    std::shared_ptr<MirWindowSpec> self;
 };
 }
 }
 
-#endif //MIRAL_TOOLKIT_SURFACE_SPEC_H_H
+#endif //MIRAL_TOOLKIT_WINDOW_SPEC_H_H

=== modified file 'include/miral/window_info.h'
--- include/miral/window_info.h	2016-12-13 13:07:15 +0000
+++ include/miral/window_info.h	2017-01-26 16:46:42 +0000
@@ -41,7 +41,7 @@
 
     bool can_be_active() const;
 
-    bool can_morph_to(MirSurfaceType new_type) const;
+    bool can_morph_to(MirWindowType new_type) const;
 
     bool must_have_parent() const;
 
@@ -49,7 +49,7 @@
 
     bool is_visible() const;
 
-    static bool needs_titlebar(MirSurfaceType type);
+    static bool needs_titlebar(MirWindowType type);
 
     void constrain_resize(mir::geometry::Point& requested_pos, mir::geometry::Size& requested_size) const;
 
@@ -58,11 +58,11 @@
     auto name() const -> std::string;
     void name(std::string const& name);
 
-    auto type() const -> MirSurfaceType;
-    void type(MirSurfaceType type);
+    auto type() const -> MirWindowType;
+    void type(MirWindowType type);
 
-    auto state() const -> MirSurfaceState;
-    void state(MirSurfaceState state);
+    auto state() const -> MirWindowState;
+    void state(MirWindowState state);
 
     auto restore_rect() const -> mir::geometry::Rectangle;
     void restore_rect(mir::geometry::Rectangle const& restore_rect);

=== modified file 'include/miral/window_management_policy.h'
--- include/miral/window_management_policy.h	2016-12-05 09:46:35 +0000
+++ include/miral/window_management_policy.h	2017-01-26 16:46:42 +0000
@@ -23,6 +23,8 @@
 #include <mir/geometry/rectangles.h>
 #include <mir_toolkit/event.h>
 
+#include <miral/detail/mir_forward_compatibility.h>
+
 namespace miral
 {
 class Window;
@@ -44,11 +46,11 @@
 
     /** Customize initial window placement
      *
-     * @param app_info                the application requesting a new surface
+     * @param app_info                the application requesting a new window
      * @param requested_specification the requested specification (updated with default placement)
      * @return                        the customized specification
      */
-    virtual auto place_new_surface(
+    virtual auto place_new_window(
         ApplicationInfo const& app_info,
         WindowSpecification const& requested_specification) -> WindowSpecification = 0;
 
@@ -141,7 +143,7 @@
      * @param window_info   the window
      * @param state         the new state
      */
-    virtual void advise_state_change(WindowInfo const& window_info, MirSurfaceState state);
+    virtual void advise_state_change(WindowInfo const& window_info, MirWindowState state);
 
     /** Notification that a window is about to move
      *

=== modified file 'include/miral/window_specification.h'
--- include/miral/window_specification.h	2016-09-30 16:29:43 +0000
+++ include/miral/window_specification.h	2017-01-26 16:46:42 +0000
@@ -21,7 +21,7 @@
 
 #include <mir_toolkit/common.h>
 
-#include "miral/detail/mir_forward_compatibility.h"
+#include <miral/detail/mir_forward_compatibility.h>
 
 #include <mir/geometry/displacement.h>
 #include <mir/geometry/rectangles.h>
@@ -76,8 +76,8 @@
     auto size() const -> mir::optional_value<Size> const&;
     auto name() const -> mir::optional_value<std::string> const&;
     auto output_id() const -> mir::optional_value<int> const&;
-    auto type() const -> mir::optional_value<MirSurfaceType> const&;
-    auto state() const -> mir::optional_value<MirSurfaceState> const&;
+    auto type() const -> mir::optional_value<MirWindowType> const&;
+    auto state() const -> mir::optional_value<MirWindowState> const&;
     auto preferred_orientation() const -> mir::optional_value<MirOrientationMode> const&;
     auto aux_rect() const -> mir::optional_value<Rectangle> const&;
     auto placement_hints() const -> mir::optional_value<MirPlacementHints> const&;
@@ -104,8 +104,8 @@
     auto size() -> mir::optional_value<Size>&;
     auto name() -> mir::optional_value<std::string>&;
     auto output_id() -> mir::optional_value<int>&;
-    auto type() -> mir::optional_value<MirSurfaceType>&;
-    auto state() -> mir::optional_value<MirSurfaceState>&;
+    auto type() -> mir::optional_value<MirWindowType>&;
+    auto state() -> mir::optional_value<MirWindowState>&;
     auto preferred_orientation() -> mir::optional_value<MirOrientationMode>&;
     auto aux_rect() -> mir::optional_value<Rectangle>&;
     auto placement_hints() -> mir::optional_value<MirPlacementHints>&;

=== modified file 'miral-kiosk/kiosk_window_manager.cpp'
--- miral-kiosk/kiosk_window_manager.cpp	2016-11-08 11:16:10 +0000
+++ miral-kiosk/kiosk_window_manager.cpp	2017-01-26 16:46:42 +0000
@@ -125,16 +125,16 @@
 
 void KioskWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
 {
-    // We do this here, not in place_new_surface() so that clients get a resize event.
+    // We do this here, not in place_new_window() so that clients get a resize event.
     // This shouldn't be necessary, but works better with the gtk-mir backend.
     if (maximize_root_windows &&
-        window_info.type() == mir_surface_type_normal &&
+        window_info.type() == mir_window_type_normal &&
         !window_info.parent() &&
-        window_info.state() == mir_surface_state_restored)
+        window_info.state() == mir_window_state_restored)
     {
         WindowSpecification specification;
 
-        specification.state() = mir_surface_state_maximized;
+        specification.state() = mir_window_state_maximized;
 
         tools.place_and_size_for_state(specification, window_info);
         tools.modify_window(window_info.window(), specification);

=== modified file 'miral-kiosk/sw_splash.cpp'
--- miral-kiosk/sw_splash.cpp	2016-05-11 11:45:10 +0000
+++ miral-kiosk/sw_splash.cpp	2017-01-26 16:46:42 +0000
@@ -18,8 +18,14 @@
 
 #include "sw_splash.h"
 
+#include <miral/detail/mir_forward_compatibility.h>
+
 #include <mir_toolkit/mir_connection.h>
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
 #include <mir_toolkit/mir_surface.h>
+#else
+#include <mir_toolkit/mir_window.h>
+#endif
 #include <mir_toolkit/mir_buffer_stream.h>
 
 #include <chrono>
@@ -59,9 +65,9 @@
     return *pixel_formats;
 }
 
-auto create_surface(MirConnection* connection, MirPixelFormat pixel_format) -> MirSurface*
+auto create_window(MirConnection* connection, MirPixelFormat pixel_format) -> MirWindow*
 {
-
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     auto* spec = mir_connection_create_spec_for_normal_surface(connection, 42, 42, pixel_format);
 
     mir_surface_spec_set_name(spec, "splash");
@@ -70,6 +76,17 @@
 
     auto const surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
+#else
+    auto* spec = mir_create_normal_window_spec(connection, 42, 42);
+
+    mir_window_spec_set_name(spec, "splash");
+    mir_window_spec_set_buffer_usage(spec, mir_buffer_usage_software);
+    mir_window_spec_set_fullscreen_on_output(spec, 0);
+    mir_window_spec_set_pixel_format(spec, pixel_format);
+
+    auto const surface = mir_create_window_sync(spec);
+    mir_window_spec_release(spec);
+#endif
 
     return surface;
 }
@@ -133,10 +150,14 @@
         return;
     };
 
-    auto const surface = create_surface(connection, pixel_format);
+    auto const surface = create_window(connection, pixel_format);
 
     MirGraphicsRegion graphics_region;
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     MirBufferStream* buffer_stream = mir_surface_get_buffer_stream(surface);
+#else
+    MirBufferStream* buffer_stream = mir_window_get_buffer_stream(surface);
+#endif
 
     auto const time_limit = std::chrono::steady_clock::now() + std::chrono::seconds(2);
 
@@ -154,5 +175,9 @@
     }
     while (std::chrono::steady_clock::now() < time_limit);
 
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     mir_surface_release_sync(surface);
+#else
+    mir_window_release_sync(surface);
+#endif
 }

=== modified file 'miral-shell/miral-screencast.sh'
--- miral-shell/miral-screencast.sh	2016-11-10 15:10:32 +0000
+++ miral-shell/miral-screencast.sh	2017-01-26 16:46:42 +0000
@@ -16,11 +16,13 @@
     echo "    --height  set the capture height  [${height}]"
     echo "    --output  set the output filename [${output}]"
     echo "    --socket  set the mir socket      [${socket}]"
+    echo "    --tmpfile specify the temporary work file"
     exit 0
   elif [ "$1" == "--socket" ]; then shift; socket=$1
   elif [ "$1" == "--output" ]; then shift; output=$1
   elif [ "$1" == "--width"  ]; then shift; width=$1
   elif [ "$1" == "--height" ]; then shift; height=$1
+  elif [ "$1" == "--tmpfile" ]; then shift; tempfile=$1
   fi
   shift
 done
@@ -36,7 +38,7 @@
 if [ -e ${output} ]; then echo "Output exists, moving to ${output}~"; mv ${output} ${output}~ ;fi
 while [ ! -e "${socket}" ]; do echo "waiting for ${socket}"; sleep 1 ;done
 
-tempfile=$(mktemp)
+if [ ! -v tempfile ]; then tempfile=$(mktemp); fi
 mirscreencast --size ${width} ${height} -m ${socket} -f ${tempfile}& mirscreencast_pid=$!
 trap 'kill ${mirscreencast_pid}; rm -f -- "${tempfile}"; exit 0' INT TERM HUP EXIT
 

=== modified file 'miral-shell/spinner/eglapp.cpp'
--- miral-shell/spinner/eglapp.cpp	2016-10-07 11:06:14 +0000
+++ miral-shell/spinner/eglapp.cpp	2017-01-26 16:46:42 +0000
@@ -18,6 +18,7 @@
 
 #include "miregl.h"
 
+#include <mir_toolkit/version.h>
 
 
 float mir_eglapp_background_opacity = 1.0f;
@@ -31,6 +32,7 @@
 {
     /* eglapps are interested in the screen size, so
     use mir_connection_create_display_config */
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     MirDisplayConfiguration* display_config =
         mir_connection_create_display_config(connection);
 
@@ -48,6 +50,25 @@
     }
 
     mir_display_config_destroy(display_config);
+#else
+    MirDisplayConfig* display_config =
+        mir_connection_create_display_configuration(connection);
+
+    int const n = mir_display_config_get_num_outputs(display_config);
+
+    for (int i = 0; i != n; ++i)
+    {
+        MirOutput const *const output = mir_display_config_get_output(display_config, i);
+        if (mir_output_is_enabled(output) &&
+            mir_output_get_connection_state(output) == mir_output_connection_state_connected &&
+            mir_output_get_num_modes(output) &&
+            mir_output_get_current_mode_index(output) < (size_t)mir_output_get_num_modes(output))
+        {
+            handler(output);
+        }
+    }
+    mir_display_config_release(display_config);
+#endif
 }
 
 MirPixelFormat select_pixel_format(MirConnection* connection)
@@ -72,7 +93,7 @@
 
 std::vector<std::shared_ptr<MirEglSurface>> mir_eglapp_init(MirConnection* const connection)
 {
-    MirSurfaceParameters surfaceparm =
+    MirWindowParameters surfaceparm =
         {
             "eglappsurface",
             0, 0,
@@ -108,6 +129,7 @@
     }
 
     // but normally, we're fullscreen on every active output
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     for_each_active_output(connection, [&](MirDisplayOutput const* output)
         {
             auto const& mode = output->modes[output->current_mode];
@@ -120,6 +142,20 @@
             surfaceparm.output_id = output->output_id;
             result.push_back(std::make_shared<MirEglSurface>(mir_egl_app, surfaceparm, swapinterval));
         });
+#else
+    for_each_active_output(connection, [&](MirOutput const* output)
+        {
+            auto const& mode = mir_output_get_current_mode(output);
+
+            printf("Active output [%u] at (%d, %d) is %dx%d\n",
+                   mir_output_get_id(output),
+                   mir_output_get_position_x(output), mir_output_get_position_y(output),
+                   mir_output_mode_get_width(mode), mir_output_mode_get_height(mode));
+
+            surfaceparm.output_id = mir_output_get_id(output);
+            result.push_back(std::make_shared<MirEglSurface>(mir_egl_app, surfaceparm, swapinterval));
+        });
+#endif
 
     if (result.empty())
         throw std::runtime_error("No active outputs found.");

=== modified file 'miral-shell/spinner/miregl.cpp'
--- miral-shell/spinner/miregl.cpp	2016-09-16 16:07:56 +0000
+++ miral-shell/spinner/miregl.cpp	2017-01-26 16:46:42 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "miregl.h"
+#include <mir_toolkit/version.h>
 
 #include <cstring>
 
@@ -25,7 +26,7 @@
 public:
     MirEglApp(MirConnection* const connection, MirPixelFormat pixel_format);
 
-    EGLSurface create_surface(MirSurface* surface);
+    EGLSurface create_surface(MirWindow* window);
 
     void make_current(EGLSurface eglsurface) const;
 
@@ -58,19 +59,20 @@
 
 namespace
 {
-MirSurface* create_surface(MirConnection* const connection, MirSurfaceParameters const& surfaceparm)
+MirWindow* create_surface(MirConnection* const connection, MirWindowParameters const& parameters)
 {
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
     auto const spec = mir_connection_create_spec_for_normal_surface(
         connection,
-        surfaceparm.width,
-        surfaceparm.height,
-        surfaceparm.pixel_format);
-
-    mir_surface_spec_set_name(spec, surfaceparm.name);
-    mir_surface_spec_set_buffer_usage(spec, surfaceparm.buffer_usage);
-
-    if (!surfaceparm.width && !surfaceparm.height)
-        mir_surface_spec_set_fullscreen_on_output(spec, surfaceparm.output_id);
+        parameters.width,
+        parameters.height,
+        parameters.pixel_format);
+
+    mir_surface_spec_set_name(spec, parameters.name);
+    mir_surface_spec_set_buffer_usage(spec, parameters.buffer_usage);
+
+    if (!parameters.width && !parameters.height)
+        mir_surface_spec_set_fullscreen_on_output(spec, parameters.output_id);
 
     auto const surface = mir_surface_create_sync(spec);
     mir_surface_spec_release(spec);
@@ -78,17 +80,39 @@
     if (!mir_surface_is_valid(surface))
         throw std::runtime_error(std::string("Can't create a surface ") + mir_surface_get_error_message(surface));
 
-    if (surfaceparm.output_id != mir_display_output_id_invalid)
+    if (parameters.output_id != mir_display_output_id_invalid)
         mir_surface_set_state(surface, mir_surface_state_fullscreen);
-
+#else
+    auto const spec = mir_create_normal_window_spec(
+        connection,
+        parameters.width,
+        parameters.height);
+
+    mir_window_spec_set_pixel_format(spec, parameters.pixel_format);
+    mir_window_spec_set_name(spec, parameters.name);
+    mir_window_spec_set_buffer_usage(spec, parameters.buffer_usage);
+
+    if (!parameters.width && !parameters.height)
+        mir_window_spec_set_fullscreen_on_output(spec, parameters.output_id);
+
+    auto const surface = mir_create_window_sync(spec);
+    mir_window_spec_release(spec);
+
+    if (!mir_window_is_valid(surface))
+        throw std::runtime_error(std::string("Can't create a surface ") + mir_window_get_error_message(surface));
+
+    if (parameters.output_id != mir_display_output_id_invalid)
+        mir_window_set_state(surface, mir_window_state_fullscreen);
+#endif
     return surface;
 }
 }
 
-MirEglSurface::MirEglSurface(std::shared_ptr<MirEglApp> const& mir_egl_app, MirSurfaceParameters const& surfaceparm, int swapinterval) :
+MirEglSurface::MirEglSurface(
+    std::shared_ptr<MirEglApp> const& mir_egl_app, MirWindowParameters const& parm, int swapinterval) :
     mir_egl_app{mir_egl_app},
-    surface{create_surface(mir_egl_app->connection, surfaceparm)},
-    eglsurface{mir_egl_app->create_surface(surface)},
+    window{create_surface(mir_egl_app->connection, parm)},
+    eglsurface{mir_egl_app->create_surface(window)},
     width_{0},
     height_{0}
 {
@@ -98,7 +122,11 @@
 MirEglSurface::~MirEglSurface()
 {
     mir_egl_app->destroy_surface(eglsurface);
-    mir_surface_release_sync(surface);
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+    mir_surface_release_sync(window);
+#else
+    mir_window_release_sync(window);
+#endif
 }
 
 void MirEglSurface::egl_make_current()
@@ -173,7 +201,7 @@
              EGL_HEIGHT, 1,
              EGL_NONE
         };
-     
+
         dummy_surface = eglCreatePbufferSurface(egldisplay, eglconfig, dummy_pbuffer_attribs);
         if (dummy_surface == EGL_NO_SURFACE)
             throw std::runtime_error("eglCreatePbufferSurface failed");
@@ -182,12 +210,19 @@
     make_current(dummy_surface);
 }
 
-EGLSurface MirEglApp::create_surface(MirSurface* surface)
+EGLSurface MirEglApp::create_surface(MirWindow* window)
 {
-    auto const eglsurface = eglCreateWindowSurface(
-        egldisplay,
-        eglconfig,
-        (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window(mir_surface_get_buffer_stream(surface)), NULL);
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+    auto const eglsurface = eglCreateWindowSurface(
+        egldisplay,
+        eglconfig,
+        (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window(mir_surface_get_buffer_stream(window)), NULL);
+#else
+    auto const eglsurface = eglCreateWindowSurface(
+        egldisplay,
+        eglconfig,
+        (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window(mir_window_get_buffer_stream(window)), NULL);
+#endif
 
     if (eglsurface == EGL_NO_SURFACE)
         throw std::runtime_error("eglCreateWindowSurface failed");

=== modified file 'miral-shell/spinner/miregl.h'
--- miral-shell/spinner/miregl.h	2016-09-16 16:07:56 +0000
+++ miral-shell/spinner/miregl.h	2017-01-26 16:46:42 +0000
@@ -17,7 +17,7 @@
 #ifndef UNITYSYSTEMCOMPOSITOR_MIREGL_H
 #define UNITYSYSTEMCOMPOSITOR_MIREGL_H
 
-#include <mir_toolkit/common.h>
+#include <miral/detail/mir_forward_compatibility.h>
 #include <mir_toolkit/client_types.h>
 #include "mir_toolkit/mir_client_library.h"
 
@@ -37,7 +37,7 @@
 public:
     MirEglSurface(
         std::shared_ptr<MirEglApp> const& mir_egl_app,
-        MirSurfaceParameters const& surfaceparm,
+        MirWindowParameters const& parm,
         int swapinterval);
 
     ~MirEglSurface();
@@ -50,7 +50,7 @@
         swap_buffers();
     }
 
-    MirSurface* mir_surface() { return surface; }
+    MirWindow* mir_window() { return window; }
 
 private:
     void egl_make_current();
@@ -60,7 +60,7 @@
     unsigned int height() const;
 
     std::shared_ptr<MirEglApp> const mir_egl_app;
-    MirSurface* const surface;
+    MirWindow* const window;
     EGLSurface const eglsurface;
     int width_;
     int height_;

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2017-01-18 17:41:46 +0000
+++ miral-shell/tiling_window_manager.cpp	2017-01-26 16:46:42 +0000
@@ -108,7 +108,7 @@
     }
 }
 
-auto TilingWindowManagerPolicy::place_new_surface(
+auto TilingWindowManagerPolicy::place_new_window(
     ApplicationInfo const& app_info,
     WindowSpecification const& request_parameters)
     -> WindowSpecification
@@ -117,7 +117,7 @@
 
     parameters.userdata() = app_info.userdata();
     parameters.state() = parameters.state().is_set() ?
-                         transform_set_state(parameters.state().value()) : mir_surface_state_restored;
+                         transform_set_state(parameters.state().value()) : mir_window_state_restored;
 
     if (app_info.application() != spinner.session())
     {
@@ -147,13 +147,13 @@
 
 void TilingWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
 {
-    if (window_info.type() == mir_surface_type_normal &&
+    if (window_info.type() == mir_window_type_normal &&
         !window_info.parent() &&
-        window_info.state() == mir_surface_state_restored)
+        window_info.state() == mir_window_state_restored)
     {
         WindowSpecification specification;
 
-        specification.state() = mir_surface_state_maximized;
+        specification.state() = mir_window_state_maximized;
 
         tools.place_and_size_for_state(specification, window_info);
         constrain_size_and_place(specification, window_info.window(), tile_for(window_info));
@@ -229,17 +229,17 @@
         reset(mods.top_left());
 }
 
-auto TilingWindowManagerPolicy::transform_set_state(MirSurfaceState value)
--> MirSurfaceState
+auto TilingWindowManagerPolicy::transform_set_state(MirWindowState value)
+-> MirWindowState
 {
     switch (value)
     {
     default:
-        return mir_surface_state_restored;
+        return mir_window_state_restored;
 
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
-        return mir_surface_state_hidden;
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
+        return mir_window_state_hidden;
     }
 }
 
@@ -285,15 +285,15 @@
         switch (modifiers & modifier_mask)
         {
         case mir_input_event_modifier_alt:
-            toggle(mir_surface_state_maximized);
+            toggle(mir_window_state_maximized);
             return true;
 
         case mir_input_event_modifier_shift:
-            toggle(mir_surface_state_vertmaximized);
+            toggle(mir_window_state_vertmaximized);
             return true;
 
         case mir_input_event_modifier_ctrl:
-            toggle(mir_surface_state_horizmaximized);
+            toggle(mir_window_state_horizmaximized);
             return true;
 
         default:
@@ -427,14 +427,14 @@
     return consumes_event;
 }
 
-void TilingWindowManagerPolicy::toggle(MirSurfaceState state)
+void TilingWindowManagerPolicy::toggle(MirWindowState state)
 {
     if (auto window = tools.active_window())
     {
         auto& window_info = tools.info_for(window);
 
         if (window_info.state() == state)
-            state = mir_surface_state_restored;
+            state = mir_window_state_restored;
 
         WindowSpecification mods;
         mods.state() = transform_set_state(state);

=== modified file 'miral-shell/tiling_window_manager.h'
--- miral-shell/tiling_window_manager.h	2016-12-05 09:46:35 +0000
+++ miral-shell/tiling_window_manager.h	2017-01-26 16:46:42 +0000
@@ -54,7 +54,7 @@
 
     ~TilingWindowManagerPolicy();
 
-    auto place_new_surface(
+    auto place_new_window(
         miral::ApplicationInfo const& app_info,
         miral::WindowSpecification const& request_parameters)
         -> miral::WindowSpecification override;
@@ -91,14 +91,14 @@
     void click(Point cursor);
     void resize(Point cursor);
     void drag(Point cursor);
-    void toggle(MirSurfaceState state);
+    void toggle(MirWindowState state);
 
     miral::Application application_under(Point position);
 
     void update_tiles(Rectangles const& displays);
     void update_surfaces(miral::ApplicationInfo& info, Rectangle const& old_tile, Rectangle const& new_tile);
 
-    auto transform_set_state(MirSurfaceState value) -> MirSurfaceState;
+    auto transform_set_state(MirWindowState value) -> MirWindowState;
 
     static void clip_to_tile(miral::WindowSpecification& parameters, Rectangle const& tile);
     static void resize(miral::Window window, Point cursor, Point old_cursor, Rectangle bounds);

=== modified file 'miral-shell/titlebar_provider.cpp'
--- miral-shell/titlebar_provider.cpp	2016-10-27 14:07:51 +0000
+++ miral-shell/titlebar_provider.cpp	2017-01-26 16:46:42 +0000
@@ -19,7 +19,7 @@
 #include "titlebar_provider.h"
 #include "titlebar_config.h"
 
-#include <miral/toolkit/surface_spec.h>
+#include <miral/toolkit/window_spec.h>
 
 #include <mir_toolkit/mir_buffer_stream.h>
 
@@ -38,7 +38,7 @@
 {
 int const title_bar_height = 12;
 
-void null_surface_callback(MirSurface*, void*) {}
+void null_surface_callback(MirWindow*, void*) {}
 
 struct Printer
 {
@@ -57,9 +57,13 @@
     FT_Face face;
 };
 
-void paint_surface(MirSurface* surface, std::string const& title, int const intensity)
+void paint_surface(MirWindow* surface, std::string const& title, int const intensity)
 {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
     MirBufferStream* buffer_stream = mir_surface_get_buffer_stream(surface);
+#else
+    MirBufferStream* buffer_stream = mir_window_get_buffer_stream(surface);
+#endif
 
     // TODO sometimes buffer_stream is nullptr - find out why (and fix).
     // (Only observed when creating a lot of clients at once)
@@ -204,10 +208,10 @@
 
             buffer << std::shared_ptr<mir::scene::Surface>(window).get();
 
-            auto const spec = SurfaceSpec::for_normal_surface(
+            auto const spec = WindowSpec::for_normal_surface(
                 connection, window.size().width.as_int(), title_bar_height, mir_pixel_format_xrgb_8888)
                 .set_buffer_usage(mir_buffer_usage_software)
-                .set_type(mir_surface_type_gloss)
+                .set_type(mir_window_type_gloss)
                 .set_name(buffer.str().c_str());
 
             std::lock_guard<decltype(mutex)> lock{mutex};
@@ -230,7 +234,7 @@
         }
         else
         {
-            data->on_create = [this, title, intensity](MirSurface* surface)
+            data->on_create = [this, title, intensity](MirWindow* surface)
                 { enqueue_work([this, surface, title, intensity]{ paint_surface(surface, title, intensity); }); };
         }
     }
@@ -244,7 +248,11 @@
         {
             enqueue_work([surface]
                  {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
                      mir_surface_release(surface, &null_surface_callback, nullptr);
+#else
+                     mir_window_release(surface, &null_surface_callback, nullptr);
+#endif
                  });
         }
 
@@ -299,23 +307,23 @@
     tools.raise_tree(window_info.parent());
 }
 
-void TitlebarProvider::advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state)
+void TitlebarProvider::advise_state_change(miral::WindowInfo const& window_info, MirWindowState state)
 {
     if (auto titlebar = find_titlebar_window(window_info.window()))
     {
         miral::WindowSpecification modifications;
         switch (state)
         {
-        case mir_surface_state_maximized:
-        case mir_surface_state_vertmaximized:
-        case mir_surface_state_hidden:
-        case mir_surface_state_minimized:
-        case mir_surface_state_fullscreen:
-            modifications.state() = mir_surface_state_hidden;
+        case mir_window_state_maximized:
+        case mir_window_state_vertmaximized:
+        case mir_window_state_hidden:
+        case mir_window_state_minimized:
+        case mir_window_state_fullscreen:
+            modifications.state() = mir_window_state_hidden;
             break;
 
         default:
-            modifications.state() = mir_surface_state_restored;
+            modifications.state() = mir_window_state_restored;
             break;
         }
 
@@ -338,10 +346,14 @@
 TitlebarProvider::Data::~Data()
 {
     if (auto surface = titlebar.exchange(nullptr))
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         mir_surface_release(surface, &null_surface_callback, nullptr);
+#else
+        mir_window_release(surface, &null_surface_callback, nullptr);
+#endif
 }
 
-void TitlebarProvider::insert(MirSurface* surface, Data* data)
+void TitlebarProvider::insert(MirWindow* surface, Data* data)
 {
     data->on_create(surface);
     data->titlebar = surface;
@@ -401,4 +413,4 @@
 void Worker::stop_work()
 {
     enqueue_work([this] { work_done = true; });
-}
\ No newline at end of file
+}

=== modified file 'miral-shell/titlebar_provider.h'
--- miral-shell/titlebar_provider.h	2016-10-27 14:04:09 +0000
+++ miral-shell/titlebar_provider.h	2017-01-26 16:46:42 +0000
@@ -71,15 +71,15 @@
     void destroy_titlebar_for(miral::Window const& window);
     void resize_titlebar_for(miral::WindowInfo const& window_info, mir::geometry::Size const& size);
     void advise_new_titlebar(miral::WindowInfo const& window_info);
-    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state);
+    void advise_state_change(miral::WindowInfo const& window_info, MirWindowState state);
 
     void stop();
 
 private:
     struct Data
     {
-        std::atomic<MirSurface*> titlebar{nullptr};
-        std::function<void(MirSurface* surface)> on_create{[](MirSurface*){}};
+        std::atomic<MirWindow*> titlebar{nullptr};
+        std::function<void(MirWindow* surface)> on_create{[](MirWindow*){}};
         miral::Window window;
 
         ~Data();
@@ -97,7 +97,7 @@
     SurfaceMap window_to_titlebar;
     TitleMap windows_awaiting_titlebar;
 
-    static void insert(MirSurface* surface, Data* data);
+    static void insert(MirWindow* surface, Data* data);
     Data* find_titlebar_data(miral::Window const& window);
     miral::Window find_titlebar_window(miral::Window const& window) const;
     void repaint_titlebar_for(miral::WindowInfo const& window_info);

=== modified file 'miral-shell/titlebar_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	2016-10-27 14:04:09 +0000
+++ miral-shell/titlebar_window_manager.cpp	2017-01-26 16:46:42 +0000
@@ -109,7 +109,7 @@
             }
         }
     }
-    
+
     if (resizing && !is_resize_event)
         end_resize();
 
@@ -312,7 +312,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirSurfaceState state)
+void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirWindowState state)
 {
     CanonicalWindowManagerPolicy::advise_state_change(window_info, state);
 
@@ -347,15 +347,15 @@
         switch (modifiers)
         {
         case mir_input_event_modifier_alt:
-            toggle(mir_surface_state_maximized);
+            toggle(mir_window_state_maximized);
             return true;
 
         case mir_input_event_modifier_shift:
-            toggle(mir_surface_state_vertmaximized);
+            toggle(mir_window_state_vertmaximized);
             return true;
 
         case mir_input_event_modifier_ctrl:
-            toggle(mir_surface_state_horizmaximized);
+            toggle(mir_window_state_horizmaximized);
             return true;
 
         default:
@@ -418,8 +418,8 @@
                 break;
 
             case KEY_UP:
-                if (window_info.state() != mir_surface_state_vertmaximized &&
-                    window_info.state() != mir_surface_state_maximized)
+                if (window_info.state() != mir_window_state_vertmaximized &&
+                    window_info.state() != mir_window_state_maximized)
                 {
                     modifications.top_left() =
                         Point{active_window.top_left().x, active_display.top_left.y} + DeltaY{title_bar_height};
@@ -455,7 +455,7 @@
     return false;
 }
 
-void TitlebarWindowManagerPolicy::toggle(MirSurfaceState state)
+void TitlebarWindowManagerPolicy::toggle(MirWindowState state)
 {
     if (auto const window = tools.active_window())
     {
@@ -463,7 +463,7 @@
 
         WindowSpecification modifications;
 
-        modifications.state() = (info.state() == state) ? mir_surface_state_restored : state;
+        modifications.state() = (info.state() == state) ? mir_window_state_restored : state;
         tools.place_and_size_for_state(modifications, info);
         tools.modify_window(info, modifications);
     }
@@ -558,14 +558,14 @@
     }
 }
 
-WindowSpecification TitlebarWindowManagerPolicy::place_new_surface(
+WindowSpecification TitlebarWindowManagerPolicy::place_new_window(
     ApplicationInfo const& app_info, WindowSpecification const& request_parameters)
 {
-    auto parameters = CanonicalWindowManagerPolicy::place_new_surface(app_info, request_parameters);
+    auto parameters = CanonicalWindowManagerPolicy::place_new_window(app_info, request_parameters);
 
     bool const needs_titlebar = WindowInfo::needs_titlebar(parameters.type().value());
 
-    if (parameters.state().value() != mir_surface_state_fullscreen && needs_titlebar)
+    if (parameters.state().value() != mir_window_state_fullscreen && needs_titlebar)
         parameters.top_left() = Point{parameters.top_left().value().x, parameters.top_left().value().y + DeltaY{title_bar_height}};
 
     if (app_info.application() == titlebar_provider->session())

=== modified file 'miral-shell/titlebar_window_manager.h'
--- miral-shell/titlebar_window_manager.h	2016-09-28 11:42:35 +0000
+++ miral-shell/titlebar_window_manager.h	2017-01-26 16:46:42 +0000
@@ -37,7 +37,7 @@
     TitlebarWindowManagerPolicy(miral::WindowManagerTools const& tools, SpinnerSplash const& spinner, miral::InternalClientLauncher const& launcher);
     ~TitlebarWindowManagerPolicy();
 
-    virtual miral::WindowSpecification place_new_surface(
+    virtual miral::WindowSpecification place_new_window(
         miral::ApplicationInfo const& app_info, miral::WindowSpecification const& request_parameters) override;
 
     /** @name example event handling:
@@ -60,7 +60,7 @@
     void handle_window_ready(miral::WindowInfo& window_info) override;
     void advise_focus_lost(miral::WindowInfo const& info) override;
     void advise_focus_gained(miral::WindowInfo const& info) override;
-    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state) override;
+    void advise_state_change(miral::WindowInfo const& window_info, MirWindowState state) override;
     void advise_resize(miral::WindowInfo const& window_info, Size const& new_size) override;
     void advise_delete_window(miral::WindowInfo const& window_info) override;
     /** @} */
@@ -74,7 +74,7 @@
         mir_input_event_modifier_meta;
 
 private:
-    void toggle(MirSurfaceState state);
+    void toggle(MirWindowState state);
 
     bool resize(miral::Window const& window, Point cursor, Point old_cursor);
 

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-12-13 13:07:15 +0000
+++ miral/CMakeLists.txt	2017-01-26 16:46:42 +0000
@@ -21,9 +21,10 @@
     window_management_trace.cpp         window_management_trace.h
     xcursor_loader.cpp                  xcursor_loader.h
     xcursor.c                           xcursor.h
+    both_versions.h
 )
 
-set_source_files_properties(xcursor.c PROPERTIES COMPILE_FLAGS "${CMAKE_C_FLAGS} -std=c99 -D_GNU_SOURCE")
+set_source_files_properties(xcursor.c PROPERTIES COMPILE_DEFINITIONS _GNU_SOURCE)
 
 add_library(miral SHARED
     active_outputs.cpp                  ${CMAKE_SOURCE_DIR}/include/miral/active_outputs.h
@@ -50,10 +51,10 @@
     set_window_managment_policy.cpp     ${CMAKE_SOURCE_DIR}/include/miral/set_window_managment_policy.h
     window_management_policy.cpp        ${CMAKE_SOURCE_DIR}/include/miral/window_management_policy.h
     window_manager_tools.cpp            ${CMAKE_SOURCE_DIR}/include/miral/window_manager_tools.h
-                                        ${CMAKE_SOURCE_DIR}/include/miral/toolkit/surface_spec.h
+                                        ${CMAKE_SOURCE_DIR}/include/miral/toolkit/window_spec.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/toolkit/persistent_id.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/toolkit/connection.h
-                                        ${CMAKE_SOURCE_DIR}/include/miral/toolkit/surface.h
+                                        ${CMAKE_SOURCE_DIR}/include/miral/toolkit/window.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/detail/mir_forward_compatibility.h
 )
 

=== modified file 'miral/active_outputs.cpp'
--- miral/active_outputs.cpp	2016-12-13 13:07:15 +0000
+++ miral/active_outputs.cpp	2017-01-26 16:46:42 +0000
@@ -70,6 +70,11 @@
 
     void base_configuration_updated(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& ) override {}
 
+    void session_configuration_applied(std::shared_ptr<mir::frontend::Session> const&,
+                                               std::shared_ptr<mir::graphics::DisplayConfiguration> const&) override {}
+
+    void session_configuration_removed(std::shared_ptr<mir::frontend::Session> const&) override {}
+
     std::mutex mutex;
     std::vector<ActiveOutputsListener*> listeners;
     std::vector<Output> outputs;

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2017-01-18 17:41:46 +0000
+++ miral/basic_window_manager.cpp	2017-01-26 16:46:42 +0000
@@ -92,7 +92,7 @@
 
     auto& session_info = info_for(session);
 
-    WindowSpecification const& spec = policy->place_new_surface(session_info, place_new_surface(session_info, params));
+    WindowSpecification const& spec = policy->place_new_window(session_info, place_new_surface(session_info, params));
     scene::SurfaceCreationParameters parameters;
     spec.update(parameters);
     auto const surface_id = build(session, parameters);
@@ -112,7 +112,7 @@
     if (parent)
         info_for(parent).add_child(window);
 
-    if (window_info.state() == mir_surface_state_fullscreen)
+    if (window_info.state() == mir_window_state_fullscreen)
         fullscreen_surfaces.insert(window_info.window());
 
     policy->advise_new_window(window_info);
@@ -282,35 +282,35 @@
 int miral::BasicWindowManager::set_surface_attribute(
     std::shared_ptr<scene::Session> const& /*application*/,
     std::shared_ptr<scene::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     WindowSpecification modification;
     switch (attrib)
     {
-    case mir_surface_attrib_type:
-        modification.type() = MirSurfaceType(value);
+    case mir_window_attrib_type:
+        modification.type() = MirWindowType(value);
         break;
-    case mir_surface_attrib_state:
-        modification.state() = MirSurfaceState(value);
+    case mir_window_attrib_state:
+        modification.state() = MirWindowState(value);
         break;
 
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         modification.preferred_orientation() = MirOrientationMode(value);
         break;
 
-    case mir_surface_attrib_visibility:
-        // The client really shouldn't be trying to set this.
-        // But, as the legacy API exists, we treat it as a query
-        return surface->query(mir_surface_attrib_visibility);
-
-    case mir_surface_attrib_focus:
-        // The client really shouldn't be trying to set this.
-        // But, as the legacy API exists, we treat it as a query
-        return surface->query(mir_surface_attrib_focus);
-
-    case mir_surface_attrib_swapinterval:
-    case mir_surface_attrib_dpi:
+    case mir_window_attrib_visibility:
+        // The client really shouldn't be trying to set this.
+        // But, as the legacy API exists, we treat it as a query
+        return surface->query(mir_window_attrib_visibility);
+
+    case mir_window_attrib_focus:
+        // The client really shouldn't be trying to set this.
+        // But, as the legacy API exists, we treat it as a query
+        return surface->query(mir_window_attrib_focus);
+
+    case mir_window_attrib_swapinterval:
+    case mir_window_attrib_dpi:
     default:
         return surface->configure(attrib, value);
     }
@@ -324,13 +324,13 @@
 
     switch (attrib)
     {
-    case mir_surface_attrib_type:
+    case mir_window_attrib_type:
         return info.type();
 
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
         return info.state();
 
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         return info.preferred_orientation();
         break;
 
@@ -496,6 +496,11 @@
 
 void miral::BasicWindowManager::raise_tree(Window const& root)
 {
+    auto const& info = info_for(root);
+
+    if (auto parent = info.parent())
+        raise_tree(parent);
+
     std::vector<Window> windows;
 
     std::function<void(WindowInfo const& info)> const add_children =
@@ -509,7 +514,7 @@
             };
 
     windows.push_back(root);
-    add_children(info_for(root));
+    add_children(info);
 
     policy->advise_raise(windows);
     focus_controller->raise({begin(windows), end(windows)});
@@ -589,7 +594,7 @@
     auto& window = window_info.window();
 
     if (window_info.type() != window_info_tmp.type())
-        std::shared_ptr<scene::Surface>(window)->configure(mir_surface_attrib_type, window_info.type());
+        std::shared_ptr<scene::Surface>(window)->configure(mir_window_attrib_type, window_info.type());
 
     if (window_info.parent() != window_info_tmp.parent())
     {
@@ -616,12 +621,12 @@
     {
         switch (window_info.state())
         {
-        case mir_surface_state_restored:
-        case mir_surface_state_hidden:
+        case mir_window_state_restored:
+        case mir_window_state_hidden:
             window_info.restore_rect({window.top_left(), window.size()});
             break;
 
-        case mir_surface_state_vertmaximized:
+        case mir_window_state_vertmaximized:
         {
             auto restore_rect = window_info.restore_rect();
             restore_rect.top_left.x = window.top_left().x;
@@ -630,7 +635,7 @@
             break;
         }
 
-        case mir_surface_state_horizmaximized:
+        case mir_window_state_horizmaximized:
         {
             auto restore_rect = window_info.restore_rect();
             restore_rect.top_left.y = window.top_left().y;
@@ -740,7 +745,7 @@
 
     switch (new_state)
     {
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
         if (modifications.output_id().is_set() &&
            (!window_info.has_output_id() || modifications.output_id().value() != window_info.output_id()))
                 break;
@@ -758,19 +763,19 @@
     // window_info.restore_rect() was cached on last state change, update to reflect current window position
     switch (window_info.state())
     {
-    case mir_surface_state_restored:
-    case mir_surface_state_hidden:
+    case mir_window_state_restored:
+    case mir_window_state_hidden:
         restore_rect = {window.top_left(), window.size()};
         break;
 
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
     {
         restore_rect.top_left.x = window.top_left().x;
         restore_rect.size.width = window.size().width;
         break;
     }
 
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
     {
         restore_rect.top_left.y = window.top_left().y;
         restore_rect.size.height= window.size().height;
@@ -793,33 +798,33 @@
 
     switch (new_state)
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         rect = restore_rect;
         break;
 
-    case mir_surface_state_maximized:
+    case mir_window_state_maximized:
         rect = display_area;
         break;
 
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         rect.top_left = {display_area.top_left.x, restore_rect.top_left.y};
         rect.size = {display_area.size.width, restore_rect.size.height};
         break;
 
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         rect.top_left = {restore_rect.top_left.x, display_area.top_left.y};
         rect.size = {restore_rect.size.width, display_area.size.height};
         break;
 
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
     {
         rect = fullscreen_rect_for(window_info);
 
         break;
     }
 
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
     default:
         return;
     }
@@ -845,12 +850,12 @@
     return r;
 }
 
-void miral::BasicWindowManager::set_state(miral::WindowInfo& window_info, MirSurfaceState value)
+void miral::BasicWindowManager::set_state(miral::WindowInfo& window_info, MirWindowState value)
 {
     auto const window = window_info.window();
     auto const mir_surface = std::shared_ptr<scene::Surface>(window);
 
-    if (value != mir_surface_state_fullscreen)
+    if (value != mir_window_state_fullscreen)
     {
         fullscreen_surfaces.erase(window);
     }
@@ -864,18 +869,18 @@
         return;
     }
 
-    bool const was_hidden = window_info.state() == mir_surface_state_hidden ||
-                            window_info.state() == mir_surface_state_minimized;
+    bool const was_hidden = window_info.state() == mir_window_state_hidden ||
+                            window_info.state() == mir_window_state_minimized;
 
     policy->advise_state_change(window_info, value);
     window_info.state(value);
 
-    mir_surface->configure(mir_surface_attrib_state, value);
+    mir_surface->configure(mir_window_attrib_state, value);
 
     switch (value)
     {
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
         mir_surface->hide();
 
         if (window == active_window())
@@ -885,8 +890,6 @@
                 {
                     if (candidate == window)
                         return true;
-                    if (!std::shared_ptr<scene::Surface>(candidate)->visible())
-                        return true;
                     auto const w = candidate;
                     return !(select_active_window(w));
                 });
@@ -966,7 +969,7 @@
     {
         if (std::shared_ptr<mir::scene::Surface> surface = child)
         {
-            if (surface->type() == mir_surface_type_dialog && surface->visible())
+            if (surface->type() == mir_window_type_dialog && surface->visible())
                 return select_active_window(child);
         }
     }
@@ -1009,43 +1012,43 @@
     //                              Mir and Unity: Surfaces, input, and displays (v0.3)
     switch (window_info.type())
     {
-    case mir_surface_type_normal:   // regular
-    case mir_surface_type_utility:  // floating regular
-    case mir_surface_type_dialog:   // dialog
-    case mir_surface_type_satellite:// satellite
-    case mir_surface_type_freestyle:// freestyle
+    case mir_window_type_normal:   // regular
+    case mir_window_type_utility:  // floating regular
+    case mir_window_type_dialog:   // dialog
+    case mir_window_type_satellite:// satellite
+    case mir_window_type_freestyle:// freestyle
         break;
 
-    case mir_surface_type_gloss:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_tip:
-    case mir_surface_types:
+    case mir_window_type_gloss:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:
+    case mir_window_type_tip:
+    case mir_window_types:
         return;
     }
 
     switch (window_info.state())
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         break;
 
         // "A vertically maximised window is anchored to the top and bottom of
         // the available workspace and can have any width."
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         movement.dy = DeltaY(0);
         break;
 
         // "A horizontally maximised window is anchored to the left and right of
         // the available workspace and can have any height"
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         movement.dx = DeltaX(0);
         break;
 
         // "A maximised window is anchored to the top, bottom, left and right of the
         // available workspace. For example, if the launcher is always-visible then
         // the left-edge of the window is anchored to the right-edge of the launcher."
-    case mir_surface_state_maximized:
-    case mir_surface_state_fullscreen:
+    case mir_window_state_maximized:
+    case mir_window_state_fullscreen:
     default:
         return;
     }
@@ -1071,10 +1074,10 @@
 -> WindowSpecification
 {
     if (!parameters.type().is_set())
-        parameters.type() = mir_surface_type_normal;
+        parameters.type() = mir_window_type_normal;
 
     if (!parameters.state().is_set())
-        parameters.state() = mir_surface_state_restored;
+        parameters.state() = mir_window_state_restored;
 
     auto const active_display_area = active_display();
     auto const height = parameters.size().value().height.as_int();
@@ -1090,7 +1093,7 @@
         display_layout->place_in_output(id, rect);
         parameters.top_left() = rect.top_left;
         parameters.size() = rect.size;
-        parameters.state() = mir_surface_state_fullscreen;
+        parameters.state() = mir_window_state_fullscreen;
         positioned = true;
     }
     else if (!has_parent) // No parent => client can't suggest positioning
@@ -1157,19 +1160,19 @@
 
         switch (parameters.state().value())
         {
-        case mir_surface_state_fullscreen:
-        case mir_surface_state_maximized:
+        case mir_window_state_fullscreen:
+        case mir_window_state_maximized:
             parameters.top_left() = active_display_area.top_left;
             parameters.size() = active_display_area.size;
             break;
 
-        case mir_surface_state_vertmaximized:
+        case mir_window_state_vertmaximized:
             centred.y = active_display_area.top_left.y;
             parameters.top_left() = centred;
             parameters.size() = Size{parameters.size().value().width, active_display_area.size.height};
             break;
 
-        case mir_surface_state_horizmaximized:
+        case mir_window_state_horizmaximized:
             centred.x = active_display_area.top_left.x;
             parameters.top_left() = centred;
             parameters.size() = Size{active_display_area.size.width, parameters.size().value().height};
@@ -1525,37 +1528,37 @@
 
         switch (original_type)
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_satellite:
-            switch (target_type)
-            {
-            case mir_surface_type_normal:
-            case mir_surface_type_utility:
-            case mir_surface_type_dialog:
-            case mir_surface_type_satellite:
-                break;
-
-            default:
-                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
-            }
-
-        case mir_surface_type_menu:
-            switch (target_type)
-            {
-            case mir_surface_type_menu:
-            case mir_surface_type_satellite:
-                break;
-
-            default:
-                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
-            }
-
-        case mir_surface_type_gloss:
-        case mir_surface_type_freestyle:
-        case mir_surface_type_inputmethod:
-        case mir_surface_type_tip:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_satellite:
+            switch (target_type)
+            {
+            case mir_window_type_normal:
+            case mir_window_type_utility:
+            case mir_window_type_dialog:
+            case mir_window_type_satellite:
+                break;
+
+            default:
+                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
+            }
+
+        case mir_window_type_menu:
+            switch (target_type)
+            {
+            case mir_window_type_menu:
+            case mir_window_type_satellite:
+                break;
+
+            default:
+                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
+            }
+
+        case mir_window_type_gloss:
+        case mir_window_type_freestyle:
+        case mir_window_type_inputmethod:
+        case mir_window_type_tip:
             if (target_type != original_type)
                 BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
             break;
@@ -1567,23 +1570,23 @@
 
     switch (target_type)
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
         if (modifications.parent().is_set() ? modifications.parent().value().lock() : window_info.parent())
-            BOOST_THROW_EXCEPTION(std::runtime_error("Surface type must not have a parent"));
+            BOOST_THROW_EXCEPTION(std::runtime_error("Window type must not have a parent"));
         break;
 
-    case mir_surface_type_satellite:
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:
+    case mir_window_type_satellite:
+    case mir_window_type_gloss:
+    case mir_window_type_tip:
         if (modifications.parent().is_set() ? !modifications.parent().value().lock() : !window_info.parent())
-            BOOST_THROW_EXCEPTION(std::runtime_error("Surface type must have a parent"));
+            BOOST_THROW_EXCEPTION(std::runtime_error("Window type must have a parent"));
         break;
 
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_dialog:
-    case mir_surface_type_menu:
-    case mir_surface_type_freestyle:
+    case mir_window_type_inputmethod:
+    case mir_window_type_dialog:
+    case mir_window_type_menu:
+    case mir_window_type_freestyle:
         break;
 
     default:

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-12-20 15:34:11 +0000
+++ miral/basic_window_manager.h	2017-01-26 16:46:42 +0000
@@ -94,7 +94,7 @@
     int set_surface_attribute(
         std::shared_ptr<mir::scene::Session> const& /*application*/,
         std::shared_ptr<mir::scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     auto count_applications() const -> unsigned int override;
@@ -172,7 +172,7 @@
     void erase(miral::WindowInfo const& info);
     void validate_modification_request(WindowSpecification const& modifications, WindowInfo const& window_info) const;
     void place_and_size(WindowInfo& root, Point const& new_pos, Size const& new_size);
-    void set_state(miral::WindowInfo& window_info, MirSurfaceState value);
+    void set_state(miral::WindowInfo& window_info, MirWindowState value);
     auto fullscreen_rect_for(WindowInfo const& window_info) const -> Rectangle;
     void remove_window(Application const& application, miral::WindowInfo const& info);
 };

=== added file 'miral/both_versions.h'
--- miral/both_versions.h	1970-01-01 00:00:00 +0000
+++ miral/both_versions.h	2017-01-26 16:46:42 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_BOTH_VERSIONS_H
+#define MIRAL_BOTH_VERSIONS_H
+
+#include <mir/version.h>
+
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0))
+    #ifndef __clang__
+        #define MIRAL_BOTH_VERSIONS(old_sym, old_version, new_sym, new_version)\
+        extern "C" __attribute__((alias(#new_sym))) void old_sym();\
+        __asm__(".symver old_sym,old_sym@" #old_version);\
+        __asm__(".symver new_sym,new_sym@@" #new_version);
+    #else
+        #define MIRAL_BOTH_VERSIONS(old_sym, old_version, new_sym, new_version)\
+        __asm__(".symver new_sym,old_sym@" #old_version);\
+        __asm__(".symver new_sym,new_sym@@@" #new_version);
+    #endif
+#else
+    #ifndef __clang__
+        #define MIRAL_BOTH_VERSIONS(old_sym, old_version, new_sym, new_version)\
+        extern "C" __attribute__((alias(#old_sym))) void new_sym();\
+        __asm__(".symver old_sym,old_sym@" #old_version);\
+        __asm__(".symver new_sym,new_sym@@" #new_version);
+    #else
+#define MIRAL_BOTH_VERSIONS(old_sym, old_version, new_sym, new_version)\
+        __asm__(".symver old_sym,old_sym@" #old_version);\
+        __asm__(".symver old_sym,new_sym@@@" #new_version);
+    #endif
+#endif
+
+#endif //MIRAL_BOTH_VERSIONS_H

=== modified file 'miral/canonical_window_manager.cpp'
--- miral/canonical_window_manager.cpp	2017-01-18 17:41:46 +0000
+++ miral/canonical_window_manager.cpp	2017-01-26 16:46:42 +0000
@@ -30,7 +30,14 @@
 {
 }
 
-auto miral::CanonicalWindowManagerPolicy::place_new_surface(
+#ifndef __clang__
+extern "C" __attribute__((alias("_ZN5miral28CanonicalWindowManagerPolicy16place_new_windowERKNS_15ApplicationInfoERKNS_19WindowSpecificationE"))) void _ZN5miral28CanonicalWindowManagerPolicy17place_new_surfaceERKNS_15ApplicationInfoERKNS_19WindowSpecificationE();
+__asm__(".symver _ZN5miral28CanonicalWindowManagerPolicy17place_new_surfaceERKNS_15ApplicationInfoERKNS_19WindowSpecificationE,_ZN5miral28CanonicalWindowManagerPolicy17place_new_surfaceERKNS_15ApplicationInfoERKNS_19WindowSpecificationE@MIRAL_1.0");
+#else
+__asm__(".symver _ZN5miral28CanonicalWindowManagerPolicy16place_new_windowERKNS_15ApplicationInfoERKNS_19WindowSpecificationE,_ZN5miral28CanonicalWindowManagerPolicy17place_new_surfaceERKNS_15ApplicationInfoERKNS_19WindowSpecificationE@MIRAL_1.0");
+__asm__(".symver _ZN5miral28CanonicalWindowManagerPolicy16place_new_windowERKNS_15ApplicationInfoERKNS_19WindowSpecificationE,_ZN5miral28CanonicalWindowManagerPolicy16place_new_windowERKNS_15ApplicationInfoERKNS_19WindowSpecificationE@@@MIRAL_1.1");
+#endif
+auto miral::CanonicalWindowManagerPolicy::place_new_window(
     miral::ApplicationInfo const& /*app_info*/,
     miral::WindowSpecification const& request_parameters)
     -> miral::WindowSpecification

=== modified file 'miral/coordinate_translator.cpp'
--- miral/coordinate_translator.cpp	2016-11-14 10:49:35 +0000
+++ miral/coordinate_translator.cpp	2017-01-26 16:46:42 +0000
@@ -44,3 +44,8 @@
     auto const& scene_surface = std::dynamic_pointer_cast<mir::scene::Surface>(surface);
     return scene_surface->top_left() + mir::geometry::Displacement{x, y};
 }
+
+bool miral::CoordinateTranslator::translation_supported() const
+{
+    return enabled;
+}

=== modified file 'miral/coordinate_translator.h'
--- miral/coordinate_translator.h	2016-11-14 10:49:35 +0000
+++ miral/coordinate_translator.h	2017-01-26 16:46:42 +0000
@@ -23,6 +23,11 @@
 
 #include <atomic>
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winconsistent-missing-override"
+#endif
+
 namespace miral
 {
 class CoordinateTranslator : public mir::scene::CoordinateTranslator
@@ -34,9 +39,14 @@
     auto surface_to_screen(std::shared_ptr<mir::frontend::Surface> surface, int32_t x, int32_t y)
         -> mir::geometry::Point override;
 
+    bool translation_supported() const;
+
 private:
     std::atomic<bool> enabled{false};
 };
 }
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
 
 #endif //MIRAL_COORDINATE_TRANSLATOR_H

=== modified file 'miral/keymap.cpp'
--- miral/keymap.cpp	2016-10-20 07:34:53 +0000
+++ miral/keymap.cpp	2017-01-26 16:46:42 +0000
@@ -25,7 +25,10 @@
 #include <mir/server.h>
 #include <mir/version.h>
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 1)
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)
+#include <mir/input/keymap.h>
+#include <mir/input/mir_keyboard_config.h>
+#elif MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 1)
 #include <mir/input/keymap.h>
 #include <mir/input/keyboard_configuration.h>
 #endif
@@ -112,7 +115,11 @@
 
         if (keyboard_config.is_set())
         {
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)
+            keymap = keyboard_config.value().device_keymap();
+#else
             keymap = keyboard_config.value().device_keymap;
+#endif
         }
 
         keymap.layout = layout;

=== modified file 'miral/symbols.map'
--- miral/symbols.map	2016-12-13 13:07:15 +0000
+++ miral/symbols.map	2017-01-26 16:46:42 +0000
@@ -112,7 +112,6 @@
     miral::WindowInfo::WindowInfo*;
     miral::WindowInfo::add_child*;
     miral::WindowInfo::can_be_active*;
-    miral::WindowInfo::can_morph_to*;
     miral::WindowInfo::children*;
     miral::WindowInfo::confine_pointer*;
     miral::WindowInfo::constrain_resize*;
@@ -128,15 +127,12 @@
     miral::WindowInfo::must_have_parent*;
     miral::WindowInfo::must_not_have_parent*;
     miral::WindowInfo::name*;
-    miral::WindowInfo::needs_titlebar*;
     miral::WindowInfo::operator*;
     miral::WindowInfo::output_id*;
     miral::WindowInfo::parent*;
     miral::WindowInfo::preferred_orientation*;
     miral::WindowInfo::remove_child*;
     miral::WindowInfo::restore_rect*;
-    miral::WindowInfo::state*;
-    miral::WindowInfo::type*;
     miral::WindowInfo::userdata*;
     miral::WindowInfo::width_inc*;
     miral::WindowInfo::window*;
@@ -153,7 +149,6 @@
     miral::WindowManagementPolicy::advise_new_window*;
     miral::WindowManagementPolicy::advise_raise*;
     miral::WindowManagementPolicy::advise_resize*;
-    miral::WindowManagementPolicy::advise_state_change*;
     miral::WindowManagementPolicy::operator*;
     miral::WindowManagerOptions::WindowManagerOptions*;
     miral::WindowManagerOptions::operator*;
@@ -311,5 +306,46 @@
     vtable?for?miral::toolkit::Surface;
     vtable?for?miral::toolkit::SurfaceSpec;
   };
+#    miral::WindowInfo::can_morph_to*;
+    _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType;
+
+#    miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType;
+
+#    miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE15MirSurfaceState;
+
+#    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE14MirSurfaceType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+#    miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState;
 local: *;
 };
+
+MIRAL_1.1 {
+global:
+    # miral::WindowInfo::can_morph_to*
+    _ZNK5miral10WindowInfo12can_morph_toE13MirWindowType;
+
+    #miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE13MirWindowType;
+
+    # miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE14MirWindowState;
+
+    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE13MirWindowType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+    # miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState;
+
+  extern "C++" {
+    miral::CanonicalWindowManagerPolicy::place_new_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::place_new_window*;
+  };
+} MIRAL_1.0;

=== modified file 'miral/window_info.cpp'
--- miral/window_info.cpp	2016-12-13 13:07:15 +0000
+++ miral/window_info.cpp	2017-01-26 16:46:42 +0000
@@ -18,7 +18,10 @@
 
 #include "miral/window_info.h"
 
+#include "both_versions.h"
+
 #include <mir/scene/surface.h>
+#include <mir/version.h>
 
 #include <limits>
 
@@ -41,8 +44,8 @@
 
     Window window;
     std::string name;
-    MirSurfaceType type;
-    MirSurfaceState state;
+    MirWindowType type;
+    MirWindowState state;
     mir::geometry::Rectangle restore_rect;
     Window parent;
     std::vector <Window> children;
@@ -64,8 +67,8 @@
 miral::WindowInfo::Self::Self(Window window, WindowSpecification const& params) :
     window{window},
     name{params.name().value()},
-    type{optional_value_or_default(params.type(), mir_surface_type_normal)},
-    state{optional_value_or_default(params.state(), mir_surface_state_restored)},
+    type{optional_value_or_default(params.type(), mir_window_type_normal)},
+    state{optional_value_or_default(params.state(), mir_window_state_restored)},
     restore_rect{params.top_left().value(), params.size().value()},
     min_width{optional_value_or_default(params.min_width())},
     min_height{optional_value_or_default(params.min_height())},
@@ -86,8 +89,8 @@
 }
 
 miral::WindowInfo::Self::Self() :
-    type{mir_surface_type_normal},
-    state{mir_surface_state_unknown},
+    type{mir_window_type_normal},
+    state{mir_window_state_unknown},
     preferred_orientation{mir_orientation_mode_any}
 {
 }
@@ -123,17 +126,17 @@
 {
     switch (type())
     {
-    case mir_surface_type_normal:       /**< AKA "regular"                       */
-    case mir_surface_type_utility:      /**< AKA "floating"                      */
-    case mir_surface_type_dialog:
-    case mir_surface_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
-    case mir_surface_type_freestyle:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
+    case mir_window_type_normal:       /**< AKA "regular"                       */
+    case mir_window_type_utility:      /**< AKA "floating"                      */
+    case mir_window_type_dialog:
+    case mir_window_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
+    case mir_window_type_freestyle:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
         return true;
 
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:          /**< AKA "tooltip"                       */
+    case mir_window_type_gloss:
+    case mir_window_type_tip:          /**< AKA "tooltip"                       */
     default:
         // Cannot have input focus
         return false;
@@ -144,10 +147,10 @@
 {
     switch (type())
     {
-    case mir_surface_type_overlay:;
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_satellite:
-    case mir_surface_type_tip:
+    case mir_window_type_gloss:;
+    case mir_window_type_inputmethod:
+    case mir_window_type_satellite:
+    case mir_window_type_tip:
         return true;
 
     default:
@@ -155,19 +158,22 @@
     }
 }
 
-bool miral::WindowInfo::can_morph_to(MirSurfaceType new_type) const
+MIRAL_BOTH_VERSIONS(
+    _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType, MIRAL_1.0,
+    _ZNK5miral10WindowInfo12can_morph_toE13MirWindowType,  MIRAL_1.1)
+bool miral::WindowInfo::can_morph_to(MirWindowType new_type) const
 {
     switch (new_type)
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
-    case mir_surface_type_satellite:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
+    case mir_window_type_satellite:
         switch (type())
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_satellite:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -175,14 +181,14 @@
         }
         break;
 
-    case mir_surface_type_dialog:
+    case mir_window_type_dialog:
         switch (type())
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_popover:
-        case mir_surface_type_satellite:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_menu:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -201,8 +207,8 @@
 {
     switch (type())
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
         return true;
 
     default:
@@ -214,8 +220,8 @@
 {
     switch (state())
     {
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
         return false;
     default:
         if (std::shared_ptr<mir::scene::Surface> surface = window())
@@ -312,19 +318,19 @@
 
     switch (state())
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         break;
 
         // "A vertically maximised window is anchored to the top and bottom of
         // the available workspace and can have any width."
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         new_pos.y = self->window.top_left().y;
         new_size.height = self->window.size().height;
         break;
 
         // "A horizontally maximised window is anchored to the left and right of
         // the available workspace and can have any height"
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         new_pos.x = self->window.top_left().x;
         new_size.width = self->window.size().width;
         break;
@@ -332,7 +338,7 @@
         // "A maximised window is anchored to the top, bottom, left and right of the
         // available workspace. For example, if the launcher is always-visible then
         // the left-edge of the window is anchored to the right-edge of the launcher."
-    case mir_surface_state_maximized:
+    case mir_window_state_maximized:
     default:
         new_pos.x = self->window.top_left().x;
         new_pos.y = self->window.top_left().y;
@@ -345,15 +351,18 @@
     requested_size = new_size;
 }
 
-bool miral::WindowInfo::needs_titlebar(MirSurfaceType type)
+MIRAL_BOTH_VERSIONS(
+    _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType, MIRAL_1.0,
+    _ZN5miral10WindowInfo14needs_titlebarE13MirWindowType,  MIRAL_1.1)
+bool miral::WindowInfo::needs_titlebar(MirWindowType type)
 {
     switch (type)
     {
-    case mir_surface_type_freestyle:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:
+    case mir_window_type_freestyle:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:
+    case mir_window_type_gloss:
+    case mir_window_type_tip:
         // No decorations for these surface types
         return false;
     default:
@@ -361,22 +370,28 @@
     }
 }
 
-auto miral::WindowInfo::type() const -> MirSurfaceType
+auto miral::WindowInfo::type() const -> MirWindowType
 {
     return self->type;
 }
 
-void miral::WindowInfo::type(MirSurfaceType type)
+MIRAL_BOTH_VERSIONS(
+    _ZN5miral10WindowInfo4typeE14MirSurfaceType, MIRAL_1.0,
+    _ZN5miral10WindowInfo4typeE13MirWindowType,  MIRAL_1.1)
+void miral::WindowInfo::type(MirWindowType type)
 {
     self->type = type;
 }
 
-auto miral::WindowInfo::state() const -> MirSurfaceState
+auto miral::WindowInfo::state() const -> MirWindowState
 {
     return self->state;
 }
 
-void miral::WindowInfo::state(MirSurfaceState state)
+MIRAL_BOTH_VERSIONS(
+    _ZN5miral10WindowInfo5stateE15MirSurfaceState, MIRAL_1.0,
+    _ZN5miral10WindowInfo5stateE14MirWindowState,  MIRAL_1.1)
+void miral::WindowInfo::state(MirWindowState state)
 {
     self->state = state;
 }

=== modified file 'miral/window_management_policy.cpp'
--- miral/window_management_policy.cpp	2016-08-10 11:48:02 +0000
+++ miral/window_management_policy.cpp	2017-01-26 16:46:42 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "miral/window_management_policy.h"
+#include "both_versions.h"
 
 void miral::WindowManagementPolicy::advise_begin() {}
 void miral::WindowManagementPolicy::advise_end() {}
@@ -25,7 +26,11 @@
 void miral::WindowManagementPolicy::advise_new_window(WindowInfo const& /*window_info*/) {}
 void miral::WindowManagementPolicy::advise_focus_lost(WindowInfo const& /*info*/) {}
 void miral::WindowManagementPolicy::advise_focus_gained(WindowInfo const& /*info*/) {}
-void miral::WindowManagementPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirSurfaceState /*state*/) {}
+
+MIRAL_BOTH_VERSIONS(
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState, MIRAL_1.0,
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState,  MIRAL_1.1)
+void miral::WindowManagementPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirWindowState /*state*/) {}
 void miral::WindowManagementPolicy::advise_move_to(WindowInfo const& /*window_info*/, Point /*top_left*/) {}
 void miral::WindowManagementPolicy::advise_resize(WindowInfo const& /*window_info*/, Size const& /*new_size*/) {}
 void miral::WindowManagementPolicy::advise_delete_window(WindowInfo const& /*window_info*/) {}

=== modified file 'miral/window_management_trace.cpp'
--- miral/window_management_trace.cpp	2016-12-05 09:46:35 +0000
+++ miral/window_management_trace.cpp	2017-01-26 16:46:42 +0000
@@ -29,9 +29,20 @@
 
 #define MIR_LOG_COMPONENT "miral::Window Management"
 #include <mir/log.h>
+#include <mir/report_exception.h>
 
 using mir::operator<<;
 
+#define MIRAL_TRACE_EXCEPTION \
+catch (std::exception const& x)\
+{\
+    std::stringstream out;\
+    mir::report_exception(out);\
+    mir::log_warning("%s throws %s", __func__, out.str().c_str());\
+    throw;\
+}
+
+
 namespace
 {
 std::string const null_ptr{"(null)"};
@@ -273,7 +284,7 @@
     return out.str();
 }
 
-auto dump_of(MirSurfaceState state) -> std::string
+auto dump_of(MirWindowState state) -> std::string
 {
     std::stringstream out;
     out << state;
@@ -304,95 +315,105 @@
 }
 
 auto miral::WindowManagementTrace::count_applications() const -> unsigned int
-{
+try {
     log_input();
     auto const result = wrapped.count_applications();
     mir::log_info("%s -> %d", __func__, result);
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::for_each_application(std::function<void(miral::ApplicationInfo&)> const& functor)
-{
+try {
     log_input();
     mir::log_info("%s", __func__);
     trace_count++;
     wrapped.for_each_application(functor);
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::find_application(std::function<bool(ApplicationInfo const& info)> const& predicate)
 -> Application
-{
+try {
     log_input();
     auto result = wrapped.find_application(predicate);
     mir::log_info("%s -> %s", __func__, dump_of(result).c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::info_for(std::weak_ptr<mir::scene::Session> const& session) const -> ApplicationInfo&
-{
+try {
     log_input();
     auto& result = wrapped.info_for(session);
     mir::log_info("%s -> %s", __func__, result.application()->name().c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::info_for(std::weak_ptr<mir::scene::Surface> const& surface) const -> WindowInfo&
-{
+try {
     log_input();
     auto& result = wrapped.info_for(surface);
     mir::log_info("%s -> %s", __func__, result.name().c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::info_for(Window const& window) const -> WindowInfo&
-{
+try {
     log_input();
     auto& result = wrapped.info_for(window);
     mir::log_info("%s -> %s", __func__, result.name().c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::ask_client_to_close(miral::Window const& window)
-{
+try {
     log_input();
     mir::log_info("%s -> %s", __func__, dump_of(window).c_str());
     trace_count++;
     wrapped.ask_client_to_close(window);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::force_close(miral::Window const& window)
-{
+try {
     log_input();
     mir::log_info("%s -> %s", __func__, dump_of(window).c_str());
     trace_count++;
     wrapped.force_close(window);
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::active_window() const -> Window
-{
+try {
     log_input();
     auto result = wrapped.active_window();
     mir::log_info("%s -> %s", __func__, dump_of(result).c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::select_active_window(Window const& hint) -> Window
-{
+try {
     log_input();
     auto result = wrapped.select_active_window(hint);
     mir::log_info("%s hint=%s -> %s", __func__, dump_of(hint).c_str(), dump_of(result).c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::window_at(mir::geometry::Point cursor) const -> Window
-{
+try {
     log_input();
     auto result = wrapped.window_at(cursor);
     std::stringstream out;
@@ -401,9 +422,10 @@
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::active_display() -> mir::geometry::Rectangle const
-{
+try {
     log_input();
     auto result = wrapped.active_display();
     std::stringstream out;
@@ -412,35 +434,39 @@
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::info_for_window_id(std::string const& id) const -> WindowInfo&
-{
+try {
     log_input();
     auto& result = wrapped.info_for_window_id(id);
     mir::log_info("%s id=%s -> %s", __func__, id.c_str(), dump_of(result).c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::id_for_window(Window const& window) const -> std::string
-{
+try {
     log_input();
     auto result = wrapped.id_for_window(window);
     mir::log_info("%s window=%s -> %s", __func__, dump_of(window).c_str(), result.c_str());
     trace_count++;
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::place_and_size_for_state(
     WindowSpecification& modifications, WindowInfo const& window_info) const
-{
+try {
     log_input();
     mir::log_info("%s modifications=%s window_info=%s", __func__, dump_of(modifications).c_str(), dump_of(window_info).c_str());
     wrapped.place_and_size_for_state(modifications, window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::drag_active_window(mir::geometry::Displacement movement)
-{
+try {
     log_input();
     std::stringstream out;
     out << movement;
@@ -448,79 +474,89 @@
     trace_count++;
     wrapped.drag_active_window(movement);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::focus_next_application()
-{
+try {
     log_input();
     mir::log_info("%s", __func__);
     trace_count++;
     wrapped.focus_next_application();
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::focus_next_within_application()
-{
+try {
     log_input();
     mir::log_info("%s", __func__);
     trace_count++;
     wrapped.focus_next_within_application();
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::raise_tree(miral::Window const& root)
-{
+try {
     log_input();
     mir::log_info("%s root=%s", __func__, dump_of(root).c_str());
     trace_count++;
     wrapped.raise_tree(root);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::modify_window(
     miral::WindowInfo& window_info, miral::WindowSpecification const& modifications)
-{
+try {
     log_input();
     mir::log_info("%s window_info=%s, modifications=%s",
                   __func__, dump_of(window_info).c_str(), dump_of(modifications).c_str());
     trace_count++;
     wrapped.modify_window(window_info, modifications);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::invoke_under_lock(std::function<void()> const& callback)
-{
+try {
     mir::log_info("%s", __func__);
     wrapped.invoke_under_lock(callback);
 }
+MIRAL_TRACE_EXCEPTION
 
-auto miral::WindowManagementTrace::place_new_surface(
+auto miral::WindowManagementTrace::place_new_window(
     ApplicationInfo const& app_info,
     WindowSpecification const& requested_specification) -> WindowSpecification
-{
-    auto const result = policy->place_new_surface(app_info, requested_specification);
+try {
+    auto const result = policy->place_new_window(app_info, requested_specification);
     mir::log_info("%s app_info=%s, requested_specification=%s -> %s",
               __func__, dump_of(app_info).c_str(), dump_of(requested_specification).c_str(), dump_of(result).c_str());
     return result;
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::handle_window_ready(miral::WindowInfo& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->handle_window_ready(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::handle_modify_window(
     miral::WindowInfo& window_info, miral::WindowSpecification const& modifications)
-{
+try {
     mir::log_info("%s window_info=%s, modifications=%s",
                   __func__, dump_of(window_info).c_str(), dump_of(modifications).c_str());
     policy->handle_modify_window(window_info, modifications);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::handle_raise_window(miral::WindowInfo& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->handle_raise_window(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 bool miral::WindowManagementTrace::handle_keyboard_event(MirKeyboardEvent const* event)
-{
+try {
     log_input = [event, this]
         {
             mir::log_info("handle_keyboard_event event=%s", dump_of(event).c_str());
@@ -529,9 +565,10 @@
 
     return policy->handle_keyboard_event(event);
 }
+MIRAL_TRACE_EXCEPTION
 
 bool miral::WindowManagementTrace::handle_touch_event(MirTouchEvent const* event)
-{
+try {
     log_input = [event, this]
         {
             mir::log_info("handle_touch_event event=%s", dump_of(event).c_str());
@@ -540,9 +577,10 @@
 
     return policy->handle_touch_event(event);
 }
+MIRAL_TRACE_EXCEPTION
 
 bool miral::WindowManagementTrace::handle_pointer_event(MirPointerEvent const* event)
-{
+try {
     log_input = [event, this]
         {
             mir::log_info("handle_pointer_event event=%s", dump_of(event).c_str());
@@ -551,87 +589,101 @@
 
     return policy->handle_pointer_event(event);
 }
+MIRAL_TRACE_EXCEPTION
 
 auto miral::WindowManagementTrace::confirm_inherited_move(WindowInfo const& window_info, Displacement movement)
 -> Rectangle
-{
+try {
     std::stringstream out;
     out << movement;
     mir::log_info("%s window_info=%s, movement=%s", __func__, dump_of(window_info).c_str(), out.str().c_str());
 
     return policy->confirm_inherited_move(window_info, movement);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_begin()
-{
+try {
     log_input = []{};
     trace_count.store(0);
     policy->advise_begin();
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_end()
-{
+try {
     if (trace_count.load() > 0)
         mir::log_info("====");
     policy->advise_end();
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_new_app(miral::ApplicationInfo& application)
-{
+try {
     mir::log_info("%s application=%s", __func__, dump_of(application).c_str());
     policy->advise_new_app(application);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_delete_app(miral::ApplicationInfo const& application)
-{
+try {
     mir::log_info("%s application=%s", __func__, dump_of(application).c_str());
     policy->advise_delete_app(application);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_new_window(miral::WindowInfo const& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->advise_new_window(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_focus_lost(miral::WindowInfo const& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->advise_focus_lost(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_focus_gained(miral::WindowInfo const& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->advise_focus_gained(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
-void miral::WindowManagementTrace::advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state)
-{
+void miral::WindowManagementTrace::advise_state_change(miral::WindowInfo const& window_info, MirWindowState state)
+try {
     mir::log_info("%s window_info=%s, state=%s", __func__, dump_of(window_info).c_str(), dump_of(state).c_str());
     policy->advise_state_change(window_info, state);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_move_to(miral::WindowInfo const& window_info, mir::geometry::Point top_left)
-{
+try {
     mir::log_info("%s window_info=%s, top_left=%s", __func__, dump_of(window_info).c_str(), dump_of(top_left).c_str());
     policy->advise_move_to(window_info, top_left);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_resize(miral::WindowInfo const& window_info, mir::geometry::Size const& new_size)
-{
+try {
     mir::log_info("%s window_info=%s, new_size=%s", __func__, dump_of(window_info).c_str(), dump_of(new_size).c_str());
     policy->advise_resize(window_info, new_size);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_delete_window(miral::WindowInfo const& window_info)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
     policy->advise_delete_window(window_info);
 }
+MIRAL_TRACE_EXCEPTION
 
 void miral::WindowManagementTrace::advise_raise(std::vector<miral::Window> const& windows)
-{
+try {
     mir::log_info("%s window_info=%s", __func__, dump_of(windows).c_str());
     policy->advise_raise(windows);
 }
+MIRAL_TRACE_EXCEPTION

=== modified file 'miral/window_management_trace.h'
--- miral/window_management_trace.h	2016-12-05 09:46:35 +0000
+++ miral/window_management_trace.h	2017-01-26 16:46:42 +0000
@@ -71,7 +71,7 @@
 
     virtual void invoke_under_lock(std::function<void()> const& callback) override;
 
-    virtual auto place_new_surface(
+    virtual auto place_new_window(
         ApplicationInfo const& app_info,
         WindowSpecification const& requested_specification) -> WindowSpecification override;
     virtual void handle_window_ready(WindowInfo& window_info) override;
@@ -103,7 +103,7 @@
 
     virtual void advise_focus_gained(WindowInfo const& window_info) override;
 
-    virtual void advise_state_change(WindowInfo const& window_info, MirSurfaceState state) override;
+    virtual void advise_state_change(WindowInfo const& window_info, MirWindowState state) override;
 
     virtual void advise_move_to(WindowInfo const& window_info, Point top_left) override;
 

=== modified file 'miral/window_specification.cpp'
--- miral/window_specification.cpp	2016-10-25 15:07:46 +0000
+++ miral/window_specification.cpp	2017-01-26 16:46:42 +0000
@@ -37,8 +37,8 @@
     mir::optional_value<BufferUsage> buffer_usage;
     mir::optional_value<std::string> name;
     mir::optional_value<int> output_id;
-    mir::optional_value<MirSurfaceType> type;
-    mir::optional_value<MirSurfaceState> state;
+    mir::optional_value<MirWindowType> type;
+    mir::optional_value<MirWindowState> state;
     mir::optional_value<MirOrientationMode> preferred_orientation;
     mir::optional_value<BufferStreamId> content_id;
     mir::optional_value<Rectangle> aux_rect;
@@ -403,12 +403,12 @@
     return self->output_id;
 }
 
-auto miral::WindowSpecification::type() const -> mir::optional_value<MirSurfaceType> const&
+auto miral::WindowSpecification::type() const -> mir::optional_value<MirWindowType> const&
 {
     return self->type;
 }
 
-auto miral::WindowSpecification::state() const -> mir::optional_value<MirSurfaceState> const&
+auto miral::WindowSpecification::state() const -> mir::optional_value<MirWindowState> const&
 {
     return self->state;
 }
@@ -533,12 +533,12 @@
     return self->output_id;
 }
 
-auto miral::WindowSpecification::type() -> mir::optional_value<MirSurfaceType>&
+auto miral::WindowSpecification::type() -> mir::optional_value<MirWindowType>&
 {
     return self->type;
 }
 
-auto miral::WindowSpecification::state() -> mir::optional_value<MirSurfaceState>&
+auto miral::WindowSpecification::state() -> mir::optional_value<MirWindowState>&
 {
     return self->state;
 }

=== modified file 'scripts/process_doxygen_xml.py'
--- scripts/process_doxygen_xml.py	2016-12-13 13:07:15 +0000
+++ scripts/process_doxygen_xml.py	2017-01-26 16:46:42 +0000
@@ -83,17 +83,360 @@
 
 OLD_STANZAS = '''MIRAL_1.0 {
 global:
+  extern "C++" {
+    miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    miral::ActiveOutputsListener::ActiveOutputsListener*;
+    miral::ActiveOutputsListener::advise_output_begin*;
+    miral::ActiveOutputsListener::advise_output_create*;
+    miral::ActiveOutputsListener::advise_output_delete*;
+    miral::ActiveOutputsListener::advise_output_end*;
+    miral::ActiveOutputsListener::advise_output_update*;
+    miral::ActiveOutputsListener::operator*;
+    miral::ActiveOutputsMonitor::?ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::add_listener*;
+    miral::ActiveOutputsMonitor::delete_listener*;
+    miral::ActiveOutputsMonitor::operator*;
+    miral::ActiveOutputsMonitor::process_outputs*;
+    miral::AddInitCallback::?AddInitCallback*;
+    miral::AddInitCallback::AddInitCallback*;
+    miral::AddInitCallback::operator*;
+    miral::AppendEventFilter::AppendEventFilter*;
+    miral::AppendEventFilter::operator*;
+    miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::operator*;
+    miral::ApplicationCredentials::ApplicationCredentials*;
+    miral::ApplicationCredentials::gid*;
+    miral::ApplicationCredentials::pid*;
+    miral::ApplicationCredentials::uid*;
+    miral::ApplicationInfo::?ApplicationInfo*;
+    miral::ApplicationInfo::ApplicationInfo*;
+    miral::ApplicationInfo::add_window*;
+    miral::ApplicationInfo::application*;
+    miral::ApplicationInfo::name*;
+    miral::ApplicationInfo::operator*;
+    miral::ApplicationInfo::remove_window*;
+    miral::ApplicationInfo::userdata*;
+    miral::ApplicationInfo::windows*;
+    miral::BasicSetApplicationAuthorizer::?BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::operator*;
+    miral::BasicSetApplicationAuthorizer::the_application_authorizer*;
+    miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy*;
+    miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    miral::CanonicalWindowManagerPolicy::confirm_inherited_move*;
+    miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    miral::CommandLineOption::?CommandLineOption*;
+    miral::CommandLineOption::CommandLineOption*;
+    miral::CommandLineOption::operator*;
+    miral::CursorTheme::?CursorTheme*;
+    miral::CursorTheme::CursorTheme*;
+    miral::CursorTheme::operator*;
+    miral::DebugExtension::DebugExtension*;
+    miral::DebugExtension::disable*;
+    miral::DebugExtension::enable*;
+    miral::DebugExtension::operator*;
+    miral::InternalClientLauncher::?InternalClientLauncher*;
+    miral::InternalClientLauncher::InternalClientLauncher*;
+    miral::InternalClientLauncher::launch*;
+    miral::InternalClientLauncher::operator*;
+    miral::Keymap::?Keymap*;
+    miral::Keymap::Keymap*;
+    miral::Keymap::operator*;
+    miral::Keymap::set_keymap*;
+    miral::MirRunner::?MirRunner*;
+    miral::MirRunner::MirRunner*;
+    miral::MirRunner::add_start_callback*;
+    miral::MirRunner::add_stop_callback*;
+    miral::MirRunner::run_with*;
+    miral::MirRunner::set_exception_handler*;
+    miral::MirRunner::stop*;
+    miral::Output::?Output*;
+    miral::Output::Output*;
+    miral::Output::connected*;
+    miral::Output::extents*;
+    miral::Output::form_factor*;
+    miral::Output::is_same_output*;
+    miral::Output::operator*;
+    miral::Output::orientation*;
+    miral::Output::physical_size_mm*;
+    miral::Output::pixel_format*;
+    miral::Output::power_mode*;
+    miral::Output::refresh_rate*;
+    miral::Output::scale*;
+    miral::Output::type*;
+    miral::Output::used*;
+    miral::Output::valid*;
+    miral::SetCommandLineHandler::?SetCommandLineHandler*;
+    miral::SetCommandLineHandler::SetCommandLineHandler*;
+    miral::SetCommandLineHandler::operator*;
+    miral::SetTerminator::?SetTerminator*;
+    miral::SetTerminator::SetTerminator*;
+    miral::SetTerminator::operator*;
+    miral::SetWindowManagmentPolicy::?SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::operator*;
+    miral::StartupInternalClient::?StartupInternalClient*;
+    miral::StartupInternalClient::StartupInternalClient*;
+    miral::StartupInternalClient::operator*;
+    miral::Window::?Window*;
+    miral::Window::Window*;
+    miral::Window::application*;
+    miral::Window::move_to*;
+    miral::Window::operator*;
+    miral::Window::resize*;
+    miral::Window::size*;
+    miral::Window::top_left*;
+    miral::WindowInfo::?WindowInfo*;
+    miral::WindowInfo::WindowInfo*;
+    miral::WindowInfo::add_child*;
+    miral::WindowInfo::can_be_active*;
+    miral::WindowInfo::children*;
+    miral::WindowInfo::confine_pointer*;
+    miral::WindowInfo::constrain_resize*;
+    miral::WindowInfo::has_output_id*;
+    miral::WindowInfo::height_inc*;
+    miral::WindowInfo::is_visible*;
+    miral::WindowInfo::max_aspect*;
+    miral::WindowInfo::max_height*;
+    miral::WindowInfo::max_width*;
+    miral::WindowInfo::min_aspect*;
+    miral::WindowInfo::min_height*;
+    miral::WindowInfo::min_width*;
+    miral::WindowInfo::must_have_parent*;
+    miral::WindowInfo::must_not_have_parent*;
+    miral::WindowInfo::name*;
+    miral::WindowInfo::operator*;
+    miral::WindowInfo::output_id*;
+    miral::WindowInfo::parent*;
+    miral::WindowInfo::preferred_orientation*;
+    miral::WindowInfo::remove_child*;
+    miral::WindowInfo::restore_rect*;
+    miral::WindowInfo::userdata*;
+    miral::WindowInfo::width_inc*;
+    miral::WindowInfo::window*;
+    miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    miral::WindowManagementPolicy::WindowManagementPolicy*;
+    miral::WindowManagementPolicy::advise_begin*;
+    miral::WindowManagementPolicy::advise_delete_app*;
+    miral::WindowManagementPolicy::advise_delete_window*;
+    miral::WindowManagementPolicy::advise_end*;
+    miral::WindowManagementPolicy::advise_focus_gained*;
+    miral::WindowManagementPolicy::advise_focus_lost*;
+    miral::WindowManagementPolicy::advise_move_to*;
+    miral::WindowManagementPolicy::advise_new_app*;
+    miral::WindowManagementPolicy::advise_new_window*;
+    miral::WindowManagementPolicy::advise_raise*;
+    miral::WindowManagementPolicy::advise_resize*;
+    miral::WindowManagementPolicy::operator*;
+    miral::WindowManagerOptions::WindowManagerOptions*;
+    miral::WindowManagerOptions::operator*;
+    miral::WindowManagerTools::?WindowManagerTools*;
+    miral::WindowManagerTools::WindowManagerTools*;
+    miral::WindowManagerTools::active_display*;
+    miral::WindowManagerTools::active_window*;
+    miral::WindowManagerTools::ask_client_to_close*;
+    miral::WindowManagerTools::count_applications*;
+    miral::WindowManagerTools::drag_active_window*;
+    miral::WindowManagerTools::find_application*;
+    miral::WindowManagerTools::focus_next_application*;
+    miral::WindowManagerTools::focus_next_within_application*;
+    miral::WindowManagerTools::for_each_application*;
+    miral::WindowManagerTools::force_close*;
+    miral::WindowManagerTools::id_for_window*;
+    miral::WindowManagerTools::info_for*;
+    miral::WindowManagerTools::info_for_window_id*;
+    miral::WindowManagerTools::invoke_under_lock*;
+    miral::WindowManagerTools::modify_window*;
+    miral::WindowManagerTools::operator*;
+    miral::WindowManagerTools::place_and_size_for_state*;
+    miral::WindowManagerTools::raise_tree*;
+    miral::WindowManagerTools::select_active_window*;
+    miral::WindowManagerTools::window_at*;
+    miral::WindowSpecification::?WindowSpecification*;
+    miral::WindowSpecification::WindowSpecification*;
+    miral::WindowSpecification::aux_rect*;
+    miral::WindowSpecification::aux_rect_placement_gravity*;
+    miral::WindowSpecification::aux_rect_placement_offset*;
+    miral::WindowSpecification::confine_pointer*;
+    miral::WindowSpecification::height_inc*;
+    miral::WindowSpecification::input_mode*;
+    miral::WindowSpecification::input_shape*;
+    miral::WindowSpecification::max_aspect*;
+    miral::WindowSpecification::max_height*;
+    miral::WindowSpecification::max_width*;
+    miral::WindowSpecification::min_aspect*;
+    miral::WindowSpecification::min_height*;
+    miral::WindowSpecification::min_width*;
+    miral::WindowSpecification::name*;
+    miral::WindowSpecification::operator*;
+    miral::WindowSpecification::output_id*;
+    miral::WindowSpecification::parent*;
+    miral::WindowSpecification::placement_hints*;
+    miral::WindowSpecification::preferred_orientation*;
+    miral::WindowSpecification::shell_chrome*;
+    miral::WindowSpecification::size*;
+    miral::WindowSpecification::state*;
+    miral::WindowSpecification::top_left*;
+    miral::WindowSpecification::type*;
+    miral::WindowSpecification::update*;
+    miral::WindowSpecification::userdata*;
+    miral::WindowSpecification::width_inc*;
+    miral::WindowSpecification::window_placement_gravity*;
+    miral::apply_lifecycle_state_to*;
+    miral::display_configuration_options*;
+    miral::equivalent_display_area*;
+    miral::kill*;
+    miral::name_of*;
+    miral::operator*;
+    miral::pid_of*;
+    miral::toolkit::Connection::Connection*;
+    miral::toolkit::Surface::Surface*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_begin*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_create*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_delete*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_end*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_update*;
+    non-virtual?thunk?to?miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::confirm_inherited_move*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_begin*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_end*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_lost*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_move_to*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_raise*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_resize*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_state_change*;
+    typeinfo?for?miral::ActiveOutputsListener;
+    typeinfo?for?miral::ActiveOutputsMonitor;
+    typeinfo?for?miral::AddInitCallback;
+    typeinfo?for?miral::AppendEventFilter;
+    typeinfo?for?miral::ApplicationAuthorizer;
+    typeinfo?for?miral::ApplicationCredentials;
+    typeinfo?for?miral::ApplicationInfo;
+    typeinfo?for?miral::BasicSetApplicationAuthorizer;
+    typeinfo?for?miral::CanonicalWindowManagerPolicy;
+    typeinfo?for?miral::CommandLineOption;
+    typeinfo?for?miral::CursorTheme;
+    typeinfo?for?miral::DebugExtension;
+    typeinfo?for?miral::InternalClientLauncher;
+    typeinfo?for?miral::Keymap;
+    typeinfo?for?miral::MirRunner;
+    typeinfo?for?miral::Output;
+    typeinfo?for?miral::Output::PhysicalSizeMM;
+    typeinfo?for?miral::SetCommandLineHandler;
+    typeinfo?for?miral::SetTerminator;
+    typeinfo?for?miral::SetWindowManagmentPolicy;
+    typeinfo?for?miral::StartupInternalClient;
+    typeinfo?for?miral::Window;
+    typeinfo?for?miral::WindowInfo;
+    typeinfo?for?miral::WindowManagementPolicy;
+    typeinfo?for?miral::WindowManagerOption;
+    typeinfo?for?miral::WindowManagerOptions;
+    typeinfo?for?miral::WindowManagerTools;
+    typeinfo?for?miral::WindowSpecification;
+    typeinfo?for?miral::WindowSpecification::AspectRatio;
+    typeinfo?for?miral::toolkit::Connection;
+    typeinfo?for?miral::toolkit::PersistentId;
+    typeinfo?for?miral::toolkit::Surface;
+    typeinfo?for?miral::toolkit::SurfaceSpec;
+    vtable?for?miral::ActiveOutputsListener;
+    vtable?for?miral::ActiveOutputsMonitor;
+    vtable?for?miral::AddInitCallback;
+    vtable?for?miral::AppendEventFilter;
+    vtable?for?miral::ApplicationAuthorizer;
+    vtable?for?miral::ApplicationCredentials;
+    vtable?for?miral::ApplicationInfo;
+    vtable?for?miral::BasicSetApplicationAuthorizer;
+    vtable?for?miral::CanonicalWindowManagerPolicy;
+    vtable?for?miral::CommandLineOption;
+    vtable?for?miral::CursorTheme;
+    vtable?for?miral::DebugExtension;
+    vtable?for?miral::InternalClientLauncher;
+    vtable?for?miral::Keymap;
+    vtable?for?miral::MirRunner;
+    vtable?for?miral::Output;
+    vtable?for?miral::Output::PhysicalSizeMM;
+    vtable?for?miral::SetCommandLineHandler;
+    vtable?for?miral::SetTerminator;
+    vtable?for?miral::SetWindowManagmentPolicy;
+    vtable?for?miral::StartupInternalClient;
+    vtable?for?miral::Window;
+    vtable?for?miral::WindowInfo;
+    vtable?for?miral::WindowManagementPolicy;
+    vtable?for?miral::WindowManagerOption;
+    vtable?for?miral::WindowManagerOptions;
+    vtable?for?miral::WindowManagerTools;
+    vtable?for?miral::WindowSpecification;
+    vtable?for?miral::WindowSpecification::AspectRatio;
+    vtable?for?miral::toolkit::Connection;
+    vtable?for?miral::toolkit::PersistentId;
+    vtable?for?miral::toolkit::Surface;
+    vtable?for?miral::toolkit::SurfaceSpec;
+  };
+#    miral::WindowInfo::can_morph_to*;
+    _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType;
+
+#    miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType;
+
+#    miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE15MirSurfaceState;
+
+#    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE14MirSurfaceType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+#    miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState;
+local: *;
+};
+
+MIRAL_1.1 {
+global:
+    # miral::WindowInfo::can_morph_to*
+    _ZNK5miral10WindowInfo12can_morph_toE13MirWindowType;
+
+    #miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE13MirWindowType;
+
+    # miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE14MirWindowState;
+
+    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE13MirWindowType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+    # miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState;
+
   extern "C++" {'''
 
 END_NEW_STANZA = '''  };
-local: *;
-};'''
+} MIRAL_1.0;'''
 
 def _print_report():
     print OLD_STANZAS
     for symbol in sorted(SYMBOLS['public']):
         formatted_symbol = '    {};'.format(symbol)
-        if formatted_symbol not in OLD_STANZAS:
+        if formatted_symbol not in OLD_STANZAS and 'miral::toolkit::' not in formatted_symbol:
             print formatted_symbol
     print END_NEW_STANZA
 

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2016-11-29 10:33:42 +0000
+++ test/CMakeLists.txt	2017-01-26 16:46:42 +0000
@@ -1,11 +1,11 @@
-if (MIRTEST_VERSION VERSION_LESS 0.25)
+if (MIRTEST_VERSION VERSION_LESS 0.26)
     # Mir used mix struct and class in public test headers (fixed -r 3606 in lp:mir)
     check_cxx_compiler_flag(-Wno-mismatched-tags MIRAL_COMPILE_WITH_W_NO_MISMATCHED_TAGS)
     if (MIRAL_COMPILE_WITH_W_NO_MISMATCHED_TAGS)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-mismatched-tags")
     endif()
 
-    if (NOT MIRTEST_VERSION VERSION_LESS 0.24)
+    if (MIRTEST_VERSION VERSION_EQUAL 0.24)
         # Mir 0.24 shipped with inconsistent override use in mirtest/mir/test/doubles/stub_session.h (lp:1609612)
         check_cxx_compiler_flag(-Wno-inconsistent-missing-override MIRAL_COMPILE_WITH_W_NO_INCONSISTENT_MISSING_OVERRIDE)
         if (MIRAL_COMPILE_WITH_W_NO_INCONSISTENT_MISSING_OVERRIDE)
@@ -13,11 +13,13 @@
         endif()
     endif()
 
-    # Mir uses "C" linkage to avoid name-mangling some functions that are not
-    # intended not for C compatibility (lp:1615587) (fixed -r 3668 in lp:mir)
-    check_cxx_compiler_flag(-Wno-return-type-c-linkage MIRAL_COMPILE_WITH_W_RETURN_TYPE_C_LINKAGE)
-    if (MIRAL_COMPILE_WITH_W_RETURN_TYPE_C_LINKAGE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage")
+    if (MIRTEST_VERSION VERSION_LESS 0.25)
+        # Mir uses "C" linkage to avoid name-mangling some functions that are not
+        # intended not for C compatibility (lp:1615587) (fixed -r 3668 in lp:mir)
+        check_cxx_compiler_flag(-Wno-return-type-c-linkage MIRAL_COMPILE_WITH_W_RETURN_TYPE_C_LINKAGE)
+        if (MIRAL_COMPILE_WITH_W_RETURN_TYPE_C_LINKAGE)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage")
+        endif()
     endif()
 endif()
 
@@ -52,6 +54,7 @@
     test_window_manager_tools.h
     display_reconfiguration.cpp
     active_window.cpp
+    raise_tree.cpp
 )
 
 target_link_libraries(miral-test

=== modified file 'test/active_window.cpp'
--- test/active_window.cpp	2016-11-30 17:01:17 +0000
+++ test/active_window.cpp	2017-01-26 16:46:42 +0000
@@ -18,8 +18,8 @@
 
 #include "test_server.h"
 
-#include <miral/toolkit/surface.h>
-#include <miral/toolkit/surface_spec.h>
+#include <miral/toolkit/window.h>
+#include <miral/toolkit/window_spec.h>
 #include <mir_toolkit/mir_buffer_stream.h>
 #include <mir_toolkit/version.h>
 
@@ -30,9 +30,9 @@
 #include <gtest/gtest.h>
 
 using namespace testing;
-using namespace miral;
 using namespace miral::toolkit;
 using namespace std::chrono_literals;
+using miral::WindowManagerTools;
 
 namespace
 {
@@ -46,10 +46,15 @@
         signal.wait_for(100ms);
     }
 
-    static void raise_signal_on_focus_change(MirSurface* /*surface*/, MirEvent const* event, void* context)
+    static void raise_signal_on_focus_change(MirWindow* /*surface*/, MirEvent const* event, void* context)
     {
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
         if (mir_event_get_type(event) == mir_event_type_surface &&
             mir_surface_event_get_attribute(mir_event_get_surface_event(event)) == mir_surface_attrib_focus)
+#else
+        if (mir_event_get_type(event) == mir_event_type_window &&
+            mir_window_event_get_attribute(mir_event_get_window_event(event)) == mir_window_attrib_focus)
+#endif
         {
             ((FocusChangeSync*)context)->signal.raise();
         }
@@ -61,55 +66,67 @@
     mir::test::Signal signal;
 };
 
-struct ActiveWindow : public TestServer
+struct ActiveWindow : public miral::TestServer
 {
     FocusChangeSync sync1;
     FocusChangeSync sync2;
 
-    auto create_surface(Connection const& connection, char const* name, FocusChangeSync& sync) -> Surface
+    auto create_surface(Connection const& connection, char const* name, FocusChangeSync& sync) -> Window
     {
-        auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+        auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
             .set_buffer_usage(mir_buffer_usage_software)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
             .set_name(name);
 
-        Surface const surface{spec.create_surface()};
+        Window const surface{spec.create_surface()};
 
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface)); });
+#else
+        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+#endif
         EXPECT_TRUE(sync.signal_raised());
 
         return surface;
     }
 
 #if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
-    auto create_tip(Connection const& connection, char const* name, Surface const& parent, FocusChangeSync& sync) -> Surface
+    auto create_tip(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> Window
     {
         MirRectangle aux_rect{10, 10, 10, 10};
-        auto const spec = SurfaceSpec::for_tip(connection, 50, 50, mir_pixel_format_argb_8888, parent, &aux_rect, mir_edge_attachment_any)
+        auto const spec = WindowSpec::for_tip(connection, 50, 50, mir_pixel_format_argb_8888, parent, &aux_rect, mir_edge_attachment_any)
             .set_buffer_usage(mir_buffer_usage_software)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
             .set_name(name);
 
-        Surface const surface{spec.create_surface()};
+        Window const surface{spec.create_surface()};
 
         // Expect this to timeout: A tip should not receive focus
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface)); });
+#else
+        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+#endif
         EXPECT_FALSE(sync.signal_raised());
 
         return surface;
     }
 #endif
 
-    auto create_dialog(Connection const& connection, char const* name, Surface const& parent, FocusChangeSync& sync) -> Surface
+    auto create_dialog(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> Window
     {
-        auto const spec = SurfaceSpec::for_dialog(connection, 50, 50, mir_pixel_format_argb_8888, parent)
+        auto const spec = WindowSpec::for_dialog(connection, 50, 50, mir_pixel_format_argb_8888, parent)
             .set_buffer_usage(mir_buffer_usage_software)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
             .set_name(name);
 
-        Surface const surface{spec.create_surface()};
+        Window const surface{spec.create_surface()};
 
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
         sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface)); });
+#else
+        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+#endif
         EXPECT_TRUE(sync.signal_raised());
 
         return surface;
@@ -155,7 +172,11 @@
     auto const connection = connect_client(test_name);
     auto const surface = create_surface(connection, test_name, sync1);
 
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
     sync1.exec([&]{ mir_surface_set_state(surface, mir_surface_state_hidden); });
+#else
+    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+#endif
 
     EXPECT_TRUE(sync1.signal_raised());
     assert_no_active_window();
@@ -166,9 +187,15 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
     auto const surface = create_surface(connection, test_name, sync1);
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
     sync1.exec([&]{ mir_surface_set_state(surface, mir_surface_state_hidden); });
 
     sync1.exec([&]{ mir_surface_set_state(surface, mir_surface_state_restored); });
+#else
+    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+
+    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_restored); });
+#endif
     EXPECT_TRUE(sync1.signal_raised());
 
     assert_active_window_is(test_name);
@@ -193,7 +220,11 @@
     auto const first_surface = create_surface(connection, test_name, sync1);
     auto const surface = create_surface(connection, another_name, sync2);
 
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
     sync2.exec([&]{ mir_surface_set_state(surface, mir_surface_state_hidden); });
+#else
+    sync2.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+#endif
 
     EXPECT_TRUE(sync2.signal_raised());
     assert_active_window_is(test_name);
@@ -207,11 +238,17 @@
     auto const first_surface = create_surface(connection, test_name, sync1);
     auto const surface = create_surface(connection, another_name, sync2);
 
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
     sync1.exec([&]{ mir_surface_set_state(surface, mir_surface_state_hidden); });
 
     // Expect this to timeout
     sync2.exec([&]{ mir_surface_set_state(surface, mir_surface_state_restored); });
+#else
+    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
 
+    // Expect this to timeout
+    sync2.exec([&]{ mir_window_set_state(surface, mir_window_state_restored); });
+#endif
     EXPECT_THAT(sync2.signal_raised(), Eq(false));
     assert_active_window_is(test_name);
 }
@@ -271,7 +308,7 @@
 
     auto const parent = create_surface(connection, test_name, sync1);
 
-    Window parent_window;
+    miral::Window parent_window;
     invoke_tools([&](WindowManagerTools& tools){ parent_window = tools.active_window(); });
 
     // Steal the focus
@@ -299,7 +336,7 @@
 
     auto const parent = create_surface(connection, test_name, sync1);
 
-    Window parent_window;
+    miral::Window parent_window;
     invoke_tools([&](WindowManagerTools& tools){ parent_window = tools.active_window(); });
 
     auto const dialog = create_dialog(connection, dialog_name, parent, sync2);

=== modified file 'test/display_reconfiguration.cpp'
--- test/display_reconfiguration.cpp	2016-11-10 17:25:38 +0000
+++ test/display_reconfiguration.cpp	2017-01-26 16:46:42 +0000
@@ -51,9 +51,9 @@
     void create_fullscreen_window()
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
-        creation_parameters.type = mir_surface_type_normal;
+        creation_parameters.type = mir_window_type_normal;
         creation_parameters.size = initial_window_size;
-        creation_parameters.state = mir_surface_state_fullscreen;
+        creation_parameters.state = mir_window_state_fullscreen;
         creation_parameters.output_id = mir::graphics::DisplayConfigurationOutputId{0};
 
         EXPECT_CALL(*window_manager_policy, advise_new_window(_))
@@ -77,9 +77,9 @@
     create_fullscreen_window();
 
     WindowSpecification mods;
-    mods.state() = mir_surface_state_hidden;
+    mods.state() = mir_window_state_hidden;
     window_manager_tools.modify_window(window, mods);
-    mods.state() = mir_surface_state_fullscreen;
+    mods.state() = mir_window_state_fullscreen;
     window_manager_tools.modify_window(window, mods);
 
     Rectangle const new_display{display_area.top_left+as_displacement({display_width, Height{0}}), display_area.size};

=== modified file 'test/drag_active_window.cpp'
--- test/drag_active_window.cpp	2016-11-07 12:09:04 +0000
+++ test/drag_active_window.cpp	2017-01-26 16:46:42 +0000
@@ -36,7 +36,7 @@
 
 auto const null_window = Window{};
 
-struct DragActiveWindow : TestWindowManagerTools, WithParamInterface<MirSurfaceType>
+struct DragActiveWindow : TestWindowManagerTools, WithParamInterface<MirWindowType>
 {
     Size const initial_parent_size{600, 400};
 
@@ -48,7 +48,7 @@
         basic_window_manager.add_session(session);
     }
 
-    void create_window_of_type(MirSurfaceType type)
+    void create_window_of_type(MirWindowType type)
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
         creation_parameters.type = type;

=== modified file 'test/modify_window_state.cpp'
--- test/modify_window_state.cpp	2016-11-07 12:09:11 +0000
+++ test/modify_window_state.cpp	2017-01-26 16:46:42 +0000
@@ -36,7 +36,7 @@
 
 auto const null_window = Window{};
 
-struct ModifyWindowState : TestWindowManagerTools, WithParamInterface<MirSurfaceType>
+struct ModifyWindowState : TestWindowManagerTools, WithParamInterface<MirWindowType>
 {
     Size const initial_parent_size{600, 400};
 
@@ -48,7 +48,7 @@
         basic_window_manager.add_session(session);
     }
 
-    void create_window_of_type(MirSurfaceType type)
+    void create_window_of_type(MirWindowType type)
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
         creation_parameters.type = type;
@@ -72,11 +72,11 @@
 
 TEST_P(ForNormalSurface, state)
 {
-    auto const original_state = mir_surface_state_restored;
-    auto const new_state = MirSurfaceState(GetParam());
-    auto const state_is_visible = (new_state != mir_surface_state_minimized) && (new_state != mir_surface_state_hidden);
+    auto const original_state = mir_window_state_restored;
+    auto const new_state = MirWindowState(GetParam());
+    auto const state_is_visible = (new_state != mir_window_state_minimized) && (new_state != mir_window_state_hidden);
 
-    create_window_of_type(mir_surface_type_normal);
+    create_window_of_type(mir_window_type_normal);
     auto const& info = window_manager_tools.info_for(window);
 
     WindowSpecification mods;
@@ -95,13 +95,13 @@
 }
 
 INSTANTIATE_TEST_CASE_P(ModifyWindowState, ForNormalSurface, ::testing::Values(
-//    mir_surface_state_unknown,
-    mir_surface_state_restored,
-    mir_surface_state_minimized,
-    mir_surface_state_maximized,
-    mir_surface_state_vertmaximized,
-    mir_surface_state_fullscreen,
-    mir_surface_state_horizmaximized,
-    mir_surface_state_hidden
-//    mir_surface_states
+//    mir_window_state_unknown,
+    mir_window_state_restored,
+    mir_window_state_minimized,
+    mir_window_state_maximized,
+    mir_window_state_vertmaximized,
+    mir_window_state_fullscreen,
+    mir_window_state_horizmaximized,
+    mir_window_state_hidden
+//    mir_window_states
 ));

=== modified file 'test/persistent_surface_store.cpp'
--- test/persistent_surface_store.cpp	2016-11-23 09:51:02 +0000
+++ test/persistent_surface_store.cpp	2017-01-26 16:46:42 +0000
@@ -17,8 +17,8 @@
  */
 
 #include <miral/toolkit/persistent_id.h>
-#include <miral/toolkit/surface.h>
-#include <miral/toolkit/surface_spec.h>
+#include <miral/toolkit/window.h>
+#include <miral/toolkit/window_spec.h>
 
 #include <miral/application_info.h>
 
@@ -49,10 +49,10 @@
     using namespace miral::toolkit;
 
     auto const connection = connect_client(test_name);
-    auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
         .set_name(test_name);
 
-    Surface const surface{spec.create_surface()};
+    Window const surface{spec.create_surface()};
 
     miral::toolkit::PersistentId client_surface_id{surface};
 
@@ -71,10 +71,10 @@
     using namespace miral::toolkit;
 
     auto const connection = connect_client(test_name);
-    auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
         .set_name(test_name);
 
-    Surface const surface{spec.create_surface()};
+    Window const surface{spec.create_surface()};
 
     miral::toolkit::PersistentId client_surface_id{surface};
 
@@ -93,10 +93,10 @@
     using namespace miral::toolkit;
 
     auto const connection = connect_client(test_name);
-    auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
         .set_name(test_name);
 
-    Surface const surface{spec.create_surface()};
+    Window const surface{spec.create_surface()};
 
     miral::toolkit::PersistentId client_surface_id{surface};
 
@@ -112,10 +112,10 @@
     using namespace miral::toolkit;
 
     auto const connection = connect_client(test_name);
-    auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
         .set_name(test_name);
 
-    Surface const surface{spec.create_surface()};
+    Window const surface{spec.create_surface()};
 
     miral::toolkit::PersistentId client_surface_id{surface};
 
@@ -133,10 +133,10 @@
     using namespace miral::toolkit;
 
     auto const connection = connect_client(test_name);
-    auto const spec = SurfaceSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_surface(connection, 50, 50, mir_pixel_format_argb_8888)
         .set_name(test_name);
 
-    Surface const surface{spec.create_surface()};
+    Window const surface{spec.create_surface()};
 
     miral::toolkit::PersistentId client_surface_id{surface};
 

=== added file 'test/raise_tree.cpp'
--- test/raise_tree.cpp	1970-01-01 00:00:00 +0000
+++ test/raise_tree.cpp	2017-01-26 16:46:42 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "test_window_manager_tools.h"
+
+using namespace miral;
+using namespace testing;
+namespace mt = mir::test;
+
+namespace
+{
+X const display_left{0};
+Y const display_top{0};
+Width  const display_width{640};
+Height const display_height{480};
+
+Rectangle const display_area{{display_left, display_top}, {display_width, display_height}};
+
+struct RaiseTree : TestWindowManagerTools
+{
+    Size const initial_parent_size{600, 400};
+    Size const initial_child_size{300, 300};
+    Rectangle const rectangle_away_from_rhs{{20, 20}, {20, 20}};
+    Rectangle const rectangle_near_rhs{{590, 20}, {10, 20}};
+    Rectangle const rectangle_away_from_bottom{{20, 20}, {20, 20}};
+    Rectangle const rectangle_near_bottom{{20, 380}, {20, 20}};
+    Rectangle const rectangle_near_both_sides{{0, 20}, {600, 20}};
+    Rectangle const rectangle_near_both_sides_and_bottom{{0, 380}, {600, 20}};
+    Rectangle const rectangle_near_all_sides{{0, 20}, {600, 380}};
+    Rectangle const rectangle_near_both_bottom_right{{400, 380}, {200, 20}};
+
+    Window parent;
+    Window child;
+    Window another_window;
+
+    WindowSpecification modification;
+
+    void SetUp() override
+    {
+        basic_window_manager.add_display(display_area);
+
+        mir::scene::SurfaceCreationParameters creation_parameters;
+        basic_window_manager.add_session(session);
+
+        EXPECT_CALL(*window_manager_policy, advise_new_window(_))
+            .WillOnce(Invoke([this](WindowInfo const& window_info){ parent = window_info.window(); }))
+            .WillOnce(Invoke([this](WindowInfo const& window_info){ child = window_info.window(); }))
+            .WillOnce(Invoke([this](WindowInfo const& window_info){ another_window = window_info.window(); }));
+
+        creation_parameters.size = initial_parent_size;
+        basic_window_manager.add_surface(session, creation_parameters, &create_surface);
+
+        creation_parameters.type = mir_window_type_menu;
+        creation_parameters.parent = parent;
+        creation_parameters.size = initial_child_size;
+        basic_window_manager.add_surface(session, creation_parameters, &create_surface);
+
+        creation_parameters.type = mir_window_type_normal;
+        creation_parameters.parent.reset();
+        creation_parameters.size = display_area.size;
+        basic_window_manager.add_surface(session, creation_parameters, &create_surface);
+
+        // Clear the expectations used to capture parent & child
+        Mock::VerifyAndClearExpectations(window_manager_policy);
+    }
+};
+}
+
+TEST_F(RaiseTree, when_parent_is_raised_child_is_raised)
+{
+    EXPECT_CALL(*window_manager_policy, advise_raise(ElementsAre(parent, child)));
+    basic_window_manager.raise_tree(parent);
+}
+
+TEST_F(RaiseTree, when_child_is_raised_parent_is_raised)
+{
+    EXPECT_CALL(*window_manager_policy, advise_raise(ElementsAre(parent, child)));
+    EXPECT_CALL(*window_manager_policy, advise_raise(ElementsAre(child)));
+    basic_window_manager.raise_tree(child);
+}

=== modified file 'test/select_active_window.cpp'
--- test/select_active_window.cpp	2016-10-10 14:53:39 +0000
+++ test/select_active_window.cpp	2017-01-26 16:46:42 +0000
@@ -82,13 +82,13 @@
 {
     mir::scene::SurfaceCreationParameters creation_parameters;
     creation_parameters.name = "parent";
-    creation_parameters.type = mir_surface_type_normal;
+    creation_parameters.type = mir_window_type_normal;
     creation_parameters.size = Size{600, 400};
 
     auto parent = create_window(creation_parameters);
 
     creation_parameters.name = "dialog";
-    creation_parameters.type = mir_surface_type_dialog;
+    creation_parameters.type = mir_window_type_dialog;
     creation_parameters.parent = parent;
 
     auto dialog = create_window(creation_parameters);
@@ -102,22 +102,22 @@
 {
     mir::scene::SurfaceCreationParameters creation_parameters;
     creation_parameters.name = "parent";
-    creation_parameters.type = mir_surface_type_normal;
+    creation_parameters.type = mir_window_type_normal;
     creation_parameters.size = Size{600, 400};
 
     auto parent = create_window(creation_parameters);
 
     creation_parameters.name = "dialog";
-    creation_parameters.type = mir_surface_type_dialog;
+    creation_parameters.type = mir_window_type_dialog;
     creation_parameters.parent = parent;
 
     auto dialog = create_window(creation_parameters);
 
     WindowSpecification mods;
-    mods.state() = mir_surface_state_hidden;
+    mods.state() = mir_window_state_hidden;
     basic_window_manager.modify_window(basic_window_manager.info_for(dialog), mods);
 
     auto actual = basic_window_manager.select_active_window(parent);
     EXPECT_THAT(actual, Eq(parent))
                 << "actual=" << actual << ", expected=" << parent;
-}
\ No newline at end of file
+}

=== modified file 'test/test_window_manager_tools.h'
--- test/test_window_manager_tools.h	2016-10-10 14:53:39 +0000
+++ test/test_window_manager_tools.h	2017-01-26 16:46:42 +0000
@@ -74,11 +74,11 @@
 
 struct StubSurface : mir::test::doubles::StubSurface
 {
-    StubSurface(std::string name, MirSurfaceType type, mir::geometry::Point top_left, mir::geometry::Size size) :
+    StubSurface(std::string name, MirWindowType type, mir::geometry::Point top_left, mir::geometry::Size size) :
         name_{name}, type_{type}, top_left_{top_left}, size_{size} {}
 
     std::string name() const override { return name_; };
-    MirSurfaceType type() const { return type_; }
+    MirWindowType type() const override { return type_; }
 
     mir::geometry::Point top_left() const override { return top_left_; }
     void move_to(mir::geometry::Point const& top_left) override { top_left_ = top_left; }
@@ -86,25 +86,25 @@
     mir::geometry::Size size() const override { return  size_; }
     void resize(mir::geometry::Size const& size) override { size_ = size; }
 
-    auto state() const -> MirSurfaceState override { return state_; }
-    auto configure(MirSurfaceAttrib attrib, int value) -> int override {
+    auto state() const -> MirWindowState override { return state_; }
+    auto configure(MirWindowAttrib attrib, int value) -> int override {
         switch (attrib)
         {
-        case mir_surface_attrib_state:
-            state_ = MirSurfaceState(value);
+        case mir_window_attrib_state:
+            state_ = MirWindowState(value);
             return state_;
         default:
             return value;
         }
     }
 
-    bool visible() const override { return  state() != mir_surface_state_hidden; }
+    bool visible() const override { return  state() != mir_window_state_hidden; }
 
     std::string name_;
-    MirSurfaceType type_;
+    MirWindowType type_;
     mir::geometry::Point top_left_;
     mir::geometry::Size size_;
-    MirSurfaceState state_ = mir_surface_state_restored;
+    MirWindowState state_ = mir_window_state_restored;
 };
 
 struct StubStubSession : mir::test::doubles::StubSession
@@ -133,13 +133,14 @@
 {
     using miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy;
 
-    bool handle_touch_event(MirTouchEvent const* /*event*/) override { return false; }
-    bool handle_pointer_event(MirPointerEvent const* /*event*/) override { return false; }
-    bool handle_keyboard_event(MirKeyboardEvent const* /*event*/) override { return false; }
+    bool handle_touch_event(MirTouchEvent const* /*event*/) { return false; }
+    bool handle_pointer_event(MirPointerEvent const* /*event*/) { return false; }
+    bool handle_keyboard_event(MirKeyboardEvent const* /*event*/) { return false; }
 
     MOCK_METHOD1(advise_new_window, void (miral::WindowInfo const& window_info));
     MOCK_METHOD2(advise_move_to, void(miral::WindowInfo const& window_info, mir::geometry::Point top_left));
     MOCK_METHOD2(advise_resize, void(miral::WindowInfo const& window_info, mir::geometry::Size const& new_size));
+    MOCK_METHOD1(advise_raise, void(std::vector<miral::Window> const&));
 };
 
 struct TestWindowManagerTools : testing::Test
@@ -158,7 +159,7 @@
         mir::test::fake_shared(persistent_surface_store),
         [this](miral::WindowManagerTools const& tools) -> std::unique_ptr<miral::WindowManagementPolicy>
             {
-                auto policy = std::make_unique<MockWindowManagerPolicy>(tools);
+                auto policy = std::make_unique<testing::NiceMock<MockWindowManagerPolicy>>(tools);
                 window_manager_policy = policy.get();
                 window_manager_tools = tools;
                 return std::move(policy);

=== modified file 'test/window_placement.cpp'
--- test/window_placement.cpp	2016-09-19 12:04:12 +0000
+++ test/window_placement.cpp	2017-01-26 16:46:42 +0000
@@ -73,7 +73,7 @@
         creation_parameters.size = initial_parent_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
 
-        creation_parameters.type = mir_surface_type_menu;
+        creation_parameters.type = mir_window_type_menu;
         creation_parameters.parent = parent;
         creation_parameters.size = initial_child_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
@@ -121,12 +121,12 @@
     ASSERT_THAT(parent, Ne(null_window));
     ASSERT_THAT(parent.size(), Eq(initial_parent_size));
     ASSERT_THAT(basic_window_manager.info_for(parent).children(), ElementsAre(child));
-    ASSERT_THAT(basic_window_manager.info_for(parent).type(), Eq(mir_surface_type_normal));
+    ASSERT_THAT(basic_window_manager.info_for(parent).type(), Eq(mir_window_type_normal));
 
     ASSERT_THAT(child, Ne(null_window));
     ASSERT_THAT(child.size(), Eq(initial_child_size));
     ASSERT_THAT(basic_window_manager.info_for(child).parent(), Eq(parent));
-    ASSERT_THAT(basic_window_manager.info_for(child).type(), Eq(mir_surface_type_menu));
+    ASSERT_THAT(basic_window_manager.info_for(child).type(), Eq(mir_window_type_menu));
 }
 
 

=== modified file 'test/window_placement_anchors_to_parent.cpp'
--- test/window_placement_anchors_to_parent.cpp	2016-09-19 14:06:02 +0000
+++ test/window_placement_anchors_to_parent.cpp	2017-01-26 16:46:42 +0000
@@ -71,7 +71,7 @@
         creation_parameters.size = parent_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
 
-        creation_parameters.type = mir_surface_type_tip;
+        creation_parameters.type = mir_window_type_tip;
         creation_parameters.parent = parent;
         creation_parameters.size = initial_child_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);

=== modified file 'test/window_placement_client_api.cpp'
--- test/window_placement_client_api.cpp	2016-09-15 13:50:33 +0000
+++ test/window_placement_client_api.cpp	2017-01-26 16:46:42 +0000
@@ -17,13 +17,19 @@
  */
 
 #include <mir/version.h>
+#include <mir_toolkit/version.h>
 
 #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
 #include <mir_toolkit/events/surface_placement.h>
+#else
+#include <mir_toolkit/events/window_placement.h>
+#endif
 #endif
 
-#include <miral/toolkit/surface_spec.h>
-#include <miral/toolkit/surface.h>
+#include <miral/detail/mir_forward_compatibility.h>
+#include <miral/toolkit/window_spec.h>
+#include <miral/toolkit/window.h>
 
 #include <mir/test/signal.h>
 #include "test_server.h"
@@ -50,7 +56,7 @@
         char const* const test_name = __PRETTY_FUNCTION__;
 
         connection = connect_client(test_name);
-        auto spec = SurfaceSpec::for_normal_surface(connection, 400, 400, mir_pixel_format_argb_8888)
+        auto spec = WindowSpec::for_normal_surface(connection, 400, 400, mir_pixel_format_argb_8888)
             .set_name(test_name);
 
         parent = spec.create_surface();
@@ -66,13 +72,17 @@
     }
 
     Connection connection;
-    Surface parent;
-    Surface child;
+    Window parent;
+    Window child;
 };
 }
 
 #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
 
+#if MIR_CLIENT_VERSION == MIR_VERSION_NUMBER(3, 4, 0)
+auto const mir_event_type_window_placement   = mir_event_type_surface_placement;
+#endif
+
 namespace
 {
 struct CheckPlacement
@@ -80,21 +90,30 @@
     CheckPlacement(int left, int top, unsigned int width, unsigned int height) :
         expected{left, top, width, height} {}
 
-    void check(MirSurfacePlacementEvent const* placement_event)
+    void check(MirWindowPlacementEvent const* placement_event)
     {
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).top, Eq(expected.top));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).left, Eq(expected.left));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).height, Eq(expected.height));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).width, Eq(expected.width));
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+        auto relative_position = mir_surface_placement_get_relative_position(placement_event);
+#else
+        auto relative_position = mir_window_placement_get_relative_position(placement_event);
+#endif
+        EXPECT_THAT(relative_position.top, Eq(expected.top));
+        EXPECT_THAT(relative_position.left, Eq(expected.left));
+        EXPECT_THAT(relative_position.height, Eq(expected.height));
+        EXPECT_THAT(relative_position.width, Eq(expected.width));
 
         received.raise();
     }
 
-    static void callback(MirSurface* /*surface*/, MirEvent const* event, void* context)
+    static void callback(MirWindow* /*surface*/, MirEvent const* event, void* context)
     {
-        if (mir_event_get_type(event) == mir_event_type_surface_placement)
+        if (mir_event_get_type(event) == mir_event_type_window_placement)
         {
+#if MIR_CLIENT_VERSION <= MIR_VERSION_NUMBER(3, 4, 0)
             auto const placement_event = mir_event_get_surface_placement_event(event);
+#else
+            auto const placement_event = mir_event_get_window_placement_event(event);
+#endif
             static_cast<CheckPlacement*>(context)->check(placement_event);
         }
     }
@@ -123,7 +142,7 @@
         MirRectangle aux_rect{10, 20, 3, 4};
         CheckPlacement expected{aux_rect.left+(int)aux_rect.width, aux_rect.top, dx, dy};
 
-        auto const spec = SurfaceSpec::
+        auto const spec = WindowSpec::
             for_menu(connection, dx, dy, mir_pixel_format_argb_8888, parent, &aux_rect, mir_edge_attachment_any)
             .set_event_handler(&CheckPlacement::callback, &expected)
             .set_name(test_name);
@@ -136,7 +155,7 @@
         MirRectangle aux_rect{50, 60, 5, 7};
         CheckPlacement expected{aux_rect.left-dx, aux_rect.top, dx, dy};
 
-        auto const spec = SurfaceSpec::for_changes(connection)
+        auto const spec = WindowSpec::for_changes(connection)
             .set_event_handler(&CheckPlacement::callback, &expected)
             .set_placement(&aux_rect, mir_placement_gravity_northwest, mir_placement_gravity_northeast, mir_placement_hints_flip_x, 0, 0);