Merge lp:~alan-griffiths/miral/1.4 into lp:miral/zesty

[Alan Griffiths]

Merge MirAL 1.4 into zesty

[lp:~alan-griffiths/miral/1.4]

361. By Alan Griffiths on 2017-06-20

Merge lp:miral for 1.4

Unmerged revisions

361. By Alan Griffiths on 2017-06-20

Merge lp:miral for 1.4

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-03-24 17:44:48 +0000
+++ CMakeLists.txt	2017-06-20 16:14:05 +0000
@@ -1,16 +1,12 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.5)
+cmake_policy(SET CMP0015 NEW)
+cmake_policy(SET CMP0022 NEW)
+
 project(miral)
 
-if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-    set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "/usr install prefix" FORCE)
-endif()
-
 include (GNUInstallDirs)
 include(CheckCXXCompilerFlag)
 
-cmake_policy(SET CMP0015 NEW)
-cmake_policy(SET CMP0022 NEW)
-
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
@@ -36,16 +32,21 @@
 
 include(FindPkgConfig)
 
-pkg_check_modules(MIRCLIENT mirclient>=0.20 REQUIRED)
+pkg_check_modules(MIRCLIENT mirclient>=0.26 REQUIRED)
 
 include_directories(include SYSTEM ${MIRCLIENT_INCLUDE_DIRS})
 
 set(MIRAL_VERSION_MAJOR 1)
-set(MIRAL_VERSION_MINOR 3)
-set(MIRAL_VERSION_PATCH 2)
+set(MIRAL_VERSION_MINOR 4)
+set(MIRAL_VERSION_PATCH 0)
 
 set(MIRAL_VERSION ${MIRAL_VERSION_MAJOR}.${MIRAL_VERSION_MINOR}.${MIRAL_VERSION_PATCH})
 
+if (MIRCLIENT_VERSION VERSION_LESS 0.26.3)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
+endif()
+
 add_subdirectory(miral)
 add_subdirectory(miral-shell)
 add_subdirectory(miral-kiosk)
@@ -54,19 +55,13 @@
 if(NOT MIRTEST_FOUND)
     message(WARNING "mirtest-dev package not installed - tests cannot be built")
 else()
-    if (MIRTEST_VERSION VERSION_LESS 0.24)
-        # building the tests is disabled by default because the mirtest-dev package is broken on xenial
-        # (lp:1583536 and lp:1603080)
-        option(MIRAL_ENABLE_TESTS "Build tests" off)
-    else()
-        option(MIRAL_ENABLE_TESTS "Build tests" on)
+    option(MIRAL_ENABLE_TESTS "Build tests" on)
+
+    if (MIRAL_ENABLE_TESTS)
+        enable_testing()
+        find_package(GMock REQUIRED)
+        add_subdirectory(test)
     endif()
-
-if (MIRAL_ENABLE_TESTS)
-    enable_testing()
-    find_package(GMock REQUIRED)
-    add_subdirectory(test)
-endif()
 endif()
 
 include (cmake/Doxygen.cmake)

=== modified file 'debian/changelog'
--- debian/changelog	2017-03-30 14:18:38 +0000
+++ debian/changelog	2017-06-20 16:14:05 +0000
@@ -1,3 +1,18 @@
+miral (1.4.0) UNRELEASED; urgency=medium
+
+  * New upstream release 1.4.0 (https://launchpad.net/miral/+milestone/1.4.0)
+    - ABI summary:
+      . miral ABI unchanged at 2
+    - Enhancements:
+      . Support for passing messages to enable Drag & Drop
+      . Support for client requested move
+      . Port to the undeprecated Mir APIs
+      . Added "--cursor-theme" option when configuring a cursor theme
+      . Drop support for Mir versions before 0.26
+    - Bugs fixed:
+
+ -- Alan Griffiths <[e-mail]>  Tue, 21 Mar 2017 17:57:20 +0000
+
 miral (1.3.2+17.04.20170330.5-0ubuntu1) zesty; urgency=medium
 
   * New upstream release 1.3.2 (https://launchpad.net/miral/+milestone/1.3.2)
@@ -74,11 +89,11 @@
       . Chrome-less shell hint does not work any more (LP: #1658117)
       . WindowSpec::set_state() wrapper for mir_window_spec_set_state()
         (LP: #1661256)
-      . "$ miral-app -kiosk" fails with "Unknown command line options: 
+      . "$ miral-app -kiosk" fails with "Unknown command line options:
         --desktop_file_hint=miral-shell.desktop" (LP: #1660933)
       . libmiral] Fix focus and movement rules for Input Method and Satellite
          windows. (LP: #1660691)
-      
+
 
  -- Alan Griffiths <[e-mail]>  Wed, 15 Feb 2017 14:05:46 +0000
 

=== modified file 'debian/control'
--- debian/control	2017-02-16 11:13:26 +0000
+++ debian/control	2017-06-20 16:14:05 +0000
@@ -14,18 +14,13 @@
                python-pil,
                google-mock (>= 1.6.0+svn437),
                python3:any,
-               libmirserver-dev,
-               libmirclient-dev,
-               mirtest-dev,
+               libmirserver-dev (>= 0.26),
+               libmirclient-dev (>= 0.26),
+               mirtest-dev (>= 0.26),
+               mir-test-tools (>= 0.26),
                libglib2.0-dev,
                libgles2-mesa-dev,
                libfreetype6-dev,
-# The following workaround missing dependencies in Mir packages
-               uuid-dev,
-               libboost-system-dev,
-               libboost-filesystem-dev,
-               mir-test-tools,
-               mir-renderer-gl-dev,
 Standards-Version: 3.9.8
 Homepage: https://launchpad.net/miral
 # If you aren't a member of ~mir-team but need to upload packaging changes,

=== modified file 'debian/libmiral2.symbols'
--- debian/libmiral2.symbols	2017-03-15 17:44:36 +0000
+++ debian/libmiral2.symbols	2017-06-20 16:14:05 +0000
@@ -389,3 +389,7 @@
  (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1
  (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1
  (c++)"miral::SetWindowManagementPolicy::operator()(mir::Server&) const@MIRAL_1.3.1" 1.3.1
+ MIRAL_1.4.0@MIRAL_1.4.0 1.4.0
+ (c++)"miral::WindowManagerTools::end_drag_and_drop()@MIRAL_1.4.0" 1.4.0
+ (c++)"miral::WindowManagerTools::start_drag_and_drop(miral::WindowInfo&, std::vector<unsigned char, std::allocator<unsigned char> > const&)@MIRAL_1.4.0" 1.4.0
+ (c++)"typeinfo for miral::WindowManagementPolicyAddendum2@MIRAL_1.4.0" 1.4.0

=== removed directory 'debian/tmp'
=== modified file 'doc/introducing_the_miral_api.md'
--- doc/introducing_the_miral_api.md	2016-08-02 13:25:18 +0000
+++ doc/introducing_the_miral_api.md	2017-06-20 16:14:05 +0000
@@ -8,14 +8,14 @@
 
 \include shell_main.cpp
 
-This shell is providing TitlebarWindowManagerPolicy, TilingWindowManagerPolicy
+This shell is providing FloatingWindowManagerPolicy, TilingWindowManagerPolicy
 and SpinnerSplash. The rest is from MirAL.
 
 If you look for the corresponding code in lp:qtmir and lp:mir you’ll find it
 less clear, more verbose and scattered over multiple files.
 
 A shell has to provide a window management policy (miral-shell provides two: 
-TitlebarWindowManagerPolicy and TilingWindowManagerPolicy). A window management
+FloatingWindowManagerPolicy and TilingWindowManagerPolicy). A window management
 policy needs to implement the \ref miral::WindowManagementPolicy interface for
 handling a set of window management events.
 

=== removed file 'include/mir/client/detail/mir_forward_compatibility.h'
--- include/mir/client/detail/mir_forward_compatibility.h	2017-02-14 13:50:07 +0000
+++ include/mir/client/detail/mir_forward_compatibility.h	1970-01-01 00:00:00 +0000
@@ -1,172 +0,0 @@
-/*
- * Copyright © 2016 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_MIR_FORWARD_COMPATIBILITY_H
-#define MIRAL_MIR_FORWARD_COMPATIBILITY_H
-
-#include <mir_toolkit/version.h>
-#include <mir_toolkit/common.h>
-#include <mir/client/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 client
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 4, 0)
-
-// Inspired by GdkGravity
-/**
- * Reference point for aligning a surface relative to a rectangle.
- * Each element (surface and rectangle) has a MirPlacementGravity assigned.
- */
-typedef enum MirPlacementGravity
-{
-    /// the reference point is at the center.
-        mir_placement_gravity_center    = 0,
-
-    /// the reference point is at the middle of the left edge.
-        mir_placement_gravity_west      = 1 << 0,
-
-    /// the reference point is at the middle of the right edge.
-        mir_placement_gravity_east      = 1 << 1,
-
-    /// the reference point is in the middle of the top edge.
-        mir_placement_gravity_north     = 1 << 2,
-
-    /// the reference point is at the middle of the lower edge.
-        mir_placement_gravity_south     = 1 << 3,
-
-    /// the reference point is at the top left corner.
-        mir_placement_gravity_northwest = mir_placement_gravity_north | mir_placement_gravity_west,
-
-    /// the reference point is at the top right corner.
-        mir_placement_gravity_northeast = mir_placement_gravity_north | mir_placement_gravity_east,
-
-    /// the reference point is at the lower left corner.
-        mir_placement_gravity_southwest = mir_placement_gravity_south | mir_placement_gravity_west,
-
-    /// the reference point is at the lower right corner.
-        mir_placement_gravity_southeast = mir_placement_gravity_south | mir_placement_gravity_east
-} MirPlacementGravity;
-
-// Inspired by GdkAnchorHints
-/**
- * Positioning hints for aligning a window relative to a rectangle.
- *
- * These hints determine how the window should be positioned in the case that
- * the surface would fall off-screen if placed in its ideal position.
- *
- * For example, \p mir_placement_hints_flip_x will invert the x component of
- * \p aux_rect_placement_offset and replace \p mir_placement_gravity_northwest
- * with \p mir_placement_gravity_northeast and vice versa if the window extends
- * beyond the left or right edges of the monitor.
- *
- * If \p mir_placement_hints_slide_x is set, the window can be shifted
- * horizontally to fit on-screen.
- *
- * If \p mir_placement_hints_resize_x is set, the window can be shrunken
- * horizontally to fit.
- *
- * If \p mir_placement_hints_antipodes is set then the rect gravity may be
- * substituted with the opposite corner (e.g. \p mir_placement_gravity_northeast
- * to \p mir_placement_gravity_southwest) in combination with other options.
- *
- * When multiple flags are set, flipping should take precedence over sliding,
- * which should take precedence over resizing.
- */
-typedef enum MirPlacementHints
-{
-    /// allow flipping anchors horizontally
-        mir_placement_hints_flip_x   = 1 << 0,
-
-    /// allow flipping anchors vertically
-        mir_placement_hints_flip_y   = 1 << 1,
-
-    /// allow sliding window horizontally
-        mir_placement_hints_slide_x  = 1 << 2,
-
-    /// allow sliding window vertically
-        mir_placement_hints_slide_y  = 1 << 3,
-
-    /// allow resizing window horizontally
-        mir_placement_hints_resize_x = 1 << 4,
-
-    /// allow resizing window vertically
-        mir_placement_hints_resize_y = 1 << 5,
-
-    /// allow flipping aux_anchor to opposite corner
-        mir_placement_hints_antipodes= 1 << 6,
-
-    /// allow flipping anchors on both axes
-        mir_placement_hints_flip_any = mir_placement_hints_flip_x|mir_placement_hints_flip_y,
-
-    /// allow sliding window on both axes
-        mir_placement_hints_slide_any  = mir_placement_hints_slide_x|mir_placement_hints_slide_y,
-
-    /// allow resizing window on both axes
-        mir_placement_hints_resize_any = mir_placement_hints_resize_x|mir_placement_hints_resize_y,
-} MirPlacementHints;
-#endif
-
-#if !MIRAL_MIR_DEFINES_POINTER_CONFINEMENT
-typedef enum MirPointerConfinementState
-{
-    mir_pointer_unconfined,
-    mir_pointer_confined_to_surface,
-} MirPointerConfinementState;
-#endif
-
-#endif //MIRAL_MIR_FORWARD_COMPATIBILITY_H

=== modified file 'include/mir/client/display_config.h'
--- include/mir/client/display_config.h	2017-02-22 12:45:01 +0000
+++ include/mir/client/display_config.h	2017-06-20 16:14:05 +0000
@@ -21,7 +21,6 @@
 
 #include <mir_toolkit/mir_connection.h>
 #include <mir_toolkit/mir_display_configuration.h>
-#include <mir/client/detail/mir_features.h>
 
 #include <functional>
 #include <memory>
@@ -57,9 +56,6 @@
             enumerator(mir_display_config_get_output(*this, i));
     }
 
-#if MIR_DEFINES_DISPLAY_CONFIG_GET_MUTABLE_OUTPUT
-    // Is it worthwhile to emulate this functionality for Mir 0.21?
-    // Too many API gaps I think.
     void for_each_output(std::function<void(MirOutput*)> const& enumerator)
     {
         auto const count = mir_display_config_get_num_outputs(*this);
@@ -67,7 +63,6 @@
         for (int i = 0; i != count; ++i)
             enumerator(mir_display_config_get_mutable_output(*this, i));
     }
-#endif
 
 private:
     static void deleter(MirDisplayConfig* config) { mir_display_config_release(config); }

=== added file 'include/mir/client/surface.h'
--- include/mir/client/surface.h	1970-01-01 00:00:00 +0000
+++ include/mir/client/surface.h	2017-06-20 16:14:05 +0000
@@ -0,0 +1,50 @@
+/*
+ * 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_SURFACE_H
+#define MIRAL_SURFACE_H
+
+#include <mir_toolkit/rs/mir_render_surface.h>
+
+#include <memory>
+
+namespace mir
+{
+namespace client
+{
+/// Handle class for MirRenderSurface - provides automatic reference counting.
+class Surface
+{
+public:
+    Surface() = default;
+    explicit Surface(MirRenderSurface* spec) : self{spec, &mir_render_surface_release} {}
+
+    operator MirRenderSurface*() const { return self.get(); }
+
+    void reset() { self.reset(); }
+
+private:
+    std::shared_ptr<MirRenderSurface> self;
+};
+
+// Provide a deleted overload to avoid double release "accidents".
+void mir_render_surface_release(Surface const& surface) = delete;
+}
+}
+
+#endif //MIRAL_SURFACE_H

=== modified file 'include/mir/client/window.h'
--- include/mir/client/window.h	2017-02-22 12:45:01 +0000
+++ include/mir/client/window.h	2017-06-20 16:14:05 +0000
@@ -19,19 +19,7 @@
 #ifndef MIR_CLIENT_WINDOW_H
 #define MIR_CLIENT_WINDOW_H
 
-#include <mir/client/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;
-auto const mir_window_release           = mir_surface_release;
-auto const mir_window_get_buffer_stream = mir_surface_get_buffer_stream;
-auto const mir_window_is_valid          = mir_surface_is_valid;
-auto const mir_window_get_error_message = mir_surface_get_error_message;
-auto const mir_window_set_state         = mir_surface_set_state;
-#else
 #include <mir_toolkit/mir_window.h>
-#endif
 
 #include <memory>
 

=== modified file 'include/mir/client/window_id.h'
--- include/mir/client/window_id.h	2017-02-24 10:36:29 +0000
+++ include/mir/client/window_id.h	2017-06-20 16:14:05 +0000
@@ -19,25 +19,8 @@
 #ifndef MIR_CLIENT_WINDOW_ID_H
 #define MIR_CLIENT_WINDOW_ID_H
 
-#include <mir/client/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_request_window_id_sync = mir_surface_request_persistent_id_sync;
-#else
 #include <mir_toolkit/mir_window.h>
-#endif
-
-#if MIR_CLIENT_API_VERSION < MIR_VERSION_NUMBER(0, 26, 1)
-#if MIR_CLIENT_VERSION == MIR_VERSION_NUMBER(3, 5, 0)
-#include <mir_toolkit/mir_persistent_id.h>
-auto const mir_window_request_window_id_sync = mir_window_request_persistent_id_sync;
-#endif
-auto const mir_window_id_as_string  = mir_persistent_id_as_string;
-auto const mir_window_id_release    = mir_persistent_id_release;
-typedef struct MirPersistentId MirWindowId;
-#else
 #include <mir_toolkit/mir_window_id.h>
-#endif
 
 #include <memory>
 

=== modified file 'include/mir/client/window_spec.h'
--- include/mir/client/window_spec.h	2017-03-03 12:31:47 +0000
+++ include/mir/client/window_spec.h	2017-06-20 16:14:05 +0000
@@ -20,50 +20,14 @@
 #define MIR_CLIENT_WINDOW_SPEC_H
 
 #include <mir/client/window.h>
-#include <mir/client/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/version.h>
+#include <mir_toolkit/rs/mir_render_surface.h>
 
 #include <memory>
 
-// Forward compatibility hacks for earlier Mir versions
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
-using MirWindowCallback = mir_surface_callback;
-using MirWindowEventCallback = mir_surface_event_callback;
-auto const mir_create_window_spec               = mir_connection_create_spec_for_changes;
-auto const mir_window_spec_set_event_handler    = mir_surface_spec_set_event_handler;
-auto const mir_window_spec_set_name             = mir_surface_spec_set_name;
-auto const mir_window_spec_set_width            = mir_surface_spec_set_width;
-auto const mir_window_spec_set_height           = mir_surface_spec_set_height;
-auto const mir_window_spec_set_width_increment  = mir_surface_spec_set_width_increment;
-auto const mir_window_spec_set_height_increment = mir_surface_spec_set_height_increment;
-auto const mir_window_spec_set_buffer_usage     = mir_surface_spec_set_buffer_usage;
-auto const mir_window_spec_set_pixel_format     = mir_surface_spec_set_pixel_format;
-auto const mir_window_spec_set_type             = mir_surface_spec_set_type;
-auto const mir_window_spec_set_shell_chrome     = mir_surface_spec_set_shell_chrome;
-auto const mir_window_spec_set_min_width        = mir_surface_spec_set_min_width;
-auto const mir_window_spec_set_min_height       = mir_surface_spec_set_min_height;
-auto const mir_window_spec_set_max_width        = mir_surface_spec_set_max_width;
-auto const mir_window_spec_set_max_height       = mir_surface_spec_set_max_height;
-auto const mir_window_spec_set_parent           = mir_surface_spec_set_parent;
-auto const mir_window_spec_set_state            = mir_surface_spec_set_state;
-auto const mir_window_spec_set_fullscreen_on_output = mir_surface_spec_set_fullscreen_on_output;
-auto const mir_create_window                    = mir_surface_create;
-auto const mir_create_window_sync               = mir_surface_create_sync;
-auto const mir_window_apply_spec                = mir_surface_apply_spec;
-auto const mir_window_spec_release              = mir_surface_spec_release;
-
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
-auto const mir_window_spec_set_placement        = mir_surface_spec_set_placement;
-#endif
-#endif
-
 namespace mir
 {
 namespace client
@@ -74,126 +38,87 @@
 public:
     explicit WindowSpec(MirWindowSpec* spec) : self{spec, deleter} {}
 
-    static auto for_normal_window(MirConnection* connection, int width, int height, MirPixelFormat format) -> WindowSpec
-    {
-#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
-    }
-
-#if MIR_CLIENT_VERSION > MIR_VERSION_NUMBER(3, 4, 0)
     static auto for_normal_window(MirConnection* connection, int width, int height) -> WindowSpec
     {
         return WindowSpec{mir_create_normal_window_spec(connection, width, height)};
     }
-#endif
 
     static auto for_menu(MirConnection* connection,
                          int width,
                          int height,
-                         MirPixelFormat format,
                          MirWindow* parent,
                          MirRectangle* rect,
                          MirEdgeAttachment edge) -> WindowSpec
     {
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 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
     }
 
     static auto for_tip(MirConnection* connection,
                         int width,
                         int height,
-                        MirPixelFormat format,
                         MirWindow* parent,
                         MirRectangle* rect,
                         MirEdgeAttachment edge) -> WindowSpec
     {
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 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
-#else
-        (void)rect;
-        (void)edge;
-        return WindowSpec{mir_create_surface_spec(connection)}
-            .set_buffer_usage(mir_buffer_usage_hardware) // Required protobuf field for create_window()
-            .set_pixel_format(format)  // Required protobuf field for create_window()
-            .set_size(width, height)
-            .set_parent(parent)
-            .set_type(mir_window_type_tip);
-#endif
     }
 
     static auto for_dialog(MirConnection* connection,
                            int width,
-                           int height,
-                           MirPixelFormat format)-> WindowSpec
+                           int height)-> WindowSpec
     {
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 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,
                            MirWindow* parent) -> WindowSpec
     {
-        return for_dialog(connection, width, height, format).set_parent(parent);
+        return for_dialog(connection, width, height).set_parent(parent);
     }
 
     static auto for_input_method(MirConnection* connection, int width, int height, MirWindow* parent)
     {
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 5, 0)
         auto spec = WindowSpec{mir_create_input_method_window_spec(connection, width, height)}
-#else
-        auto spec = WindowSpec{mir_create_surface_spec(connection)}
-            .set_buffer_usage(mir_buffer_usage_hardware) // Required protobuf field for create_window()
-            .set_pixel_format(mir_pixel_format_invalid)  // Required protobuf field for create_window()
-            .set_size(width, height)
-            .set_type(mir_window_type_inputmethod)
-#endif
             .set_parent(parent);
         return spec;
     }
 
     static auto for_satellite(MirConnection* connection, int width, int height, MirWindow* parent)
     {
+#if MIR_CLIENT_API_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+        return WindowSpec{mir_create_satellite_window_spec(connection, width, height, parent)};
+#else
         // There's no mir_create_satellite_window_spec()
-        return WindowSpec{mir_create_window_spec(connection)}
-            .set_buffer_usage(mir_buffer_usage_hardware) // Required protobuf field for create_window()
-            .set_pixel_format(mir_pixel_format_invalid)  // Required protobuf field for create_window()
+        auto spec = WindowSpec{mir_create_window_spec(connection)}
             .set_size(width, height)
             .set_type(mir_window_type_satellite)
             .set_parent(parent);
+
+        mir_window_spec_set_buffer_usage(spec, mir_buffer_usage_hardware); // Required protobuf field for create_window()
+        mir_window_spec_set_pixel_format(spec, mir_pixel_format_invalid);  // Required protobuf field for create_window()
+        return spec;
+#endif
     }
 
     static auto for_gloss(MirConnection* connection, int width, int height)
     {
+#if MIR_CLIENT_API_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+        return WindowSpec{mir_create_gloss_window_spec(connection, width, height)};
+#else
         // There's no mir_create_gloss_window_spec()
-        return WindowSpec{mir_create_window_spec(connection)}
-            .set_buffer_usage(mir_buffer_usage_hardware) // Required protobuf field for create_window()
-            .set_pixel_format(mir_pixel_format_invalid)  // Required protobuf field for create_window()
+        auto spec = WindowSpec{mir_create_window_spec(connection)}
             .set_size(width, height)
             .set_type(mir_window_type_gloss);
+
+        mir_window_spec_set_buffer_usage(spec, mir_buffer_usage_hardware); // Required protobuf field for create_window()
+        mir_window_spec_set_pixel_format(spec, mir_pixel_format_invalid);  // Required protobuf field for create_window()
+        return spec;
+#endif
     }
 
     static auto for_changes(MirConnection* connection) -> WindowSpec
@@ -201,18 +126,6 @@
         return WindowSpec{mir_create_window_spec(connection)};
     }
 
-    auto set_buffer_usage(MirBufferUsage usage) -> WindowSpec&
-    {
-        mir_window_spec_set_buffer_usage(*this, usage);
-        return *this;
-    }
-
-    auto set_pixel_format(MirPixelFormat format) -> WindowSpec&
-    {
-        mir_window_spec_set_pixel_format(*this, format);
-        return *this;
-    }
-
     auto set_type(MirWindowType type) -> WindowSpec&
     {
         mir_window_spec_set_type(*this, type);
@@ -271,7 +184,6 @@
         return *this;
     }
 
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
     auto set_placement(const MirRectangle* rect,
                        MirPlacementGravity rect_gravity,
                        MirPlacementGravity surface_gravity,
@@ -282,17 +194,6 @@
         mir_window_spec_set_placement(*this, rect, rect_gravity, surface_gravity, placement_hints, offset_dx, offset_dy);
         return *this;
     }
-#else
-    auto set_placement(const MirRectangle* /*rect*/,
-                       MirPlacementGravity /*rect_gravity*/,
-                       MirPlacementGravity /*surface_gravity*/,
-                       MirPlacementHints   /*placement_hints*/,
-                       int                 /*offset_dx*/,
-                       int                 /*offset_dy*/) -> WindowSpec&
-    {
-        return *this;
-    }
-#endif
 
     auto set_parent(MirWindow* parent) -> WindowSpec&
     {
@@ -306,6 +207,20 @@
         return *this;
     }
 
+    auto add_surface(MirRenderSurface* surface, int width, int height, int displacement_x, int displacement_y)
+    -> WindowSpec&
+    {
+#if MIR_CLIENT_API_VERSION < MIR_VERSION_NUMBER(0, 27, 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        mir_window_spec_add_render_surface(*this, surface, width, height, displacement_x, displacement_y);
+#if MIR_CLIENT_API_VERSION < MIR_VERSION_NUMBER(0, 27, 0)
+#pragma GCC diagnostic pop
+#endif
+        return *this;
+    }
+
     template<typename Context>
     void create_window(void (* callback)(MirWindow*, Context*), Context* context) const
     {

=== modified file 'include/miral/cursor_theme.h'
--- include/miral/cursor_theme.h	2016-09-28 10:38:36 +0000
+++ include/miral/cursor_theme.h	2017-06-20 16:14:05 +0000
@@ -25,11 +25,11 @@
 
 namespace miral
 {
-/// Load a cursor theme
+/// Load an X-cursor theme, either the supplied default, or through the --cursor-theme config option
 class CursorTheme
 {
 public:
-    /// Specify a specific theme
+    /// Specify a default theme
     explicit CursorTheme(std::string const& theme);
     ~CursorTheme();
 

=== modified file 'include/miral/window_management_policy.h'
--- include/miral/window_management_policy.h	2017-02-14 11:49:59 +0000
+++ include/miral/window_management_policy.h	2017-06-20 16:14:05 +0000
@@ -23,8 +23,6 @@
 #include <mir/geometry/rectangles.h>
 #include <mir_toolkit/event.h>
 
-#include <mir/client/detail/mir_forward_compatibility.h>
-
 namespace miral
 {
 class Window;

=== added file 'include/miral/window_management_policy_addendum2.h'
--- include/miral/window_management_policy_addendum2.h	1970-01-01 00:00:00 +0000
+++ include/miral/window_management_policy_addendum2.h	2017-06-20 16:14:05 +0000
@@ -0,0 +1,70 @@
+/*
+ * 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_WINDOW_MANAGEMENT_ADDENDUM2_H
+#define MIRAL_WINDOW_MANAGEMENT_ADDENDUM2_H
+
+#include <mir_toolkit/client_types.h>
+#include <mir/version.h>
+
+namespace miral
+{
+struct WindowInfo;
+
+/**
+ *  Handle additional client requests.
+ *
+ *  \note This interface is intended to be implemented by a WindowManagementPolicy
+ *  implementation, we can't add these functions directly to that interface without
+ *  breaking ABI (the vtab could be incompatible).
+ *  When initializing the window manager this interface will be detected by
+ *  dynamic_cast and registered accordingly.
+ */
+class WindowManagementPolicyAddendum2
+{
+public:
+/** @name handle requests originating from the client
+ * The policy is expected to update the model as appropriate
+ *  @{ */
+    /** request from client to initiate drag and drop
+     * \note the request has already been validated against the requesting event
+     *
+     * @param window_info   the window
+     */
+    virtual void handle_request_drag_and_drop(WindowInfo& window_info) = 0;
+
+    /** request from client to initiate move
+     * \note the request has already been validated against the requesting event
+     *
+     * @param window_info   the window
+     * @param input_event   the requesting event
+     */
+    virtual void handle_request_move(WindowInfo& window_info, MirInputEvent const* input_event) = 0;
+/** @} */
+
+    virtual ~WindowManagementPolicyAddendum2() = default;
+    WindowManagementPolicyAddendum2() = default;
+    WindowManagementPolicyAddendum2(WindowManagementPolicyAddendum2 const&) = delete;
+    WindowManagementPolicyAddendum2& operator=(WindowManagementPolicyAddendum2 const&) = delete;
+};
+#if MIRAL_VERSION >= MIR_VERSION_NUMBER(2, 0, 0)
+#error "We've presumably broken ABI - please roll this interface into WindowManagementPolicy"
+#endif
+}
+
+#endif //MIRAL_WINDOW_MANAGEMENT_ADDENDUM2_H

=== modified file 'include/miral/window_manager_tools.h'
--- include/miral/window_manager_tools.h	2017-03-02 14:29:04 +0000
+++ include/miral/window_manager_tools.h	2017-06-20 16:14:05 +0000
@@ -166,6 +166,18 @@
     /// Raise window and all its children
     void raise_tree(Window const& root);
 
+    /** Start drag and drop. The handle will be passed to the client which can
+     * then use it to talk to the whatever service is being used to support drag
+     * and drop (e.g. on Ubuntu the content hub).
+     *
+     * @param window_info source window
+     * @param handle      drag handle
+     */
+    void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle);
+
+    /// End drag and drop
+    void end_drag_and_drop();
+
     /// Apply modifications to a window
     void modify_window(WindowInfo& window_info, WindowSpecification const& modifications);
 

=== modified file 'include/miral/window_specification.h'
--- include/miral/window_specification.h	2017-02-14 11:49:59 +0000
+++ include/miral/window_specification.h	2017-06-20 16:14:05 +0000
@@ -21,8 +21,6 @@
 
 #include <mir_toolkit/common.h>
 
-#include <mir/client/detail/mir_forward_compatibility.h>
-
 #include <mir/geometry/displacement.h>
 #include <mir/geometry/rectangles.h>
 #include <mir/optional_value.h>

=== modified file 'miral-kiosk/sw_splash.cpp'
--- miral-kiosk/sw_splash.cpp	2017-02-20 15:22:29 +0000
+++ miral-kiosk/sw_splash.cpp	2017-06-20 16:14:05 +0000
@@ -18,7 +18,10 @@
 
 #include "sw_splash.h"
 
+#include <mir/client/display_config.h>
+#include <mir/client/surface.h>
 #include <mir/client/window.h>
+#include <mir/client/window_spec.h>
 
 #include <mir_toolkit/mir_buffer_stream.h>
 
@@ -26,7 +29,6 @@
 #include <cstring>
 #include <thread>
 #include <mutex>
-#include <mir/client/window_spec.h>
 
 namespace
 {
@@ -60,12 +62,29 @@
     return *pixel_formats;
 }
 
-auto create_window(MirConnection* connection, MirPixelFormat pixel_format) -> mir::client::Window
+auto create_window(MirConnection* connection, mir::client::Surface const& surface) -> mir::client::Window
 {
-    return mir::client::WindowSpec::for_normal_window(connection, 42, 42, pixel_format)
+    int id = 0;
+    int width = 0;
+    int height = 0;
+
+    mir::client::DisplayConfig{connection}.for_each_output([&](MirOutput const* output)
+        {
+            if (mir_output_get_connection_state(output) == mir_output_connection_state_connected &&
+                mir_output_is_enabled(output))
+            {
+                id = mir_output_get_id(output);
+
+                MirOutputMode const* mode = mir_output_get_current_mode(output);
+                width = mir_output_mode_get_width(mode);
+                height = mir_output_mode_get_height(mode);
+            }
+        });
+
+    return mir::client::WindowSpec::for_normal_window(connection, width, height)
         .set_name("splash")
-        .set_buffer_usage(mir_buffer_usage_software)
-        .set_fullscreen_on_output(0)
+        .set_fullscreen_on_output(id)
+        .add_surface(surface, width, height, 0, 0)
         .create_window();
 }
 
@@ -128,10 +147,13 @@
         return;
     };
 
-    auto const surface = create_window(connection, pixel_format);
+
+    mir::client::Surface surface{mir_connection_create_render_surface_sync(connection, 42, 42)};
+    MirBufferStream* buffer_stream = mir_render_surface_get_buffer_stream(surface, 42, 42, pixel_format);
+
+    auto const window = create_window(connection, surface);
 
     MirGraphicsRegion graphics_region;
-    MirBufferStream* buffer_stream = mir_window_get_buffer_stream(surface);
 
     auto const time_limit = std::chrono::steady_clock::now() + std::chrono::seconds(2);
 

=== modified file 'miral-shell/CMakeLists.txt'
--- miral-shell/CMakeLists.txt	2017-02-17 10:37:47 +0000
+++ miral-shell/CMakeLists.txt	2017-06-20 16:14:05 +0000
@@ -44,19 +44,18 @@
 add_executable(miral-shell
     shell_main.cpp
     tiling_window_manager.cpp   tiling_window_manager.h
-    titlebar_window_manager.cpp titlebar_window_manager.h
+        floating_window_manager.cpp floating_window_manager.h
     decoration_provider.cpp     decoration_provider.h
     titlebar_config.cpp         titlebar_config.h
 )
 
 pkg_check_modules(FREETYPE freetype2 REQUIRED)
-target_include_directories(miral-shell PUBLIC ${FREETYPE_INCLUDE_DIRS})
-target_compile_definitions(miral-shell PUBLIC -DTYPO_SUPPORTS_FREETYPE)
-target_link_libraries(miral-shell ${FREETYPE_LIBRARIES})
-
+target_include_directories(miral-shell PRIVATE ${FREETYPE_INCLUDE_DIRS})
+target_compile_definitions(miral-shell PRIVATE -DTYPO_SUPPORTS_FREETYPE)
 target_link_libraries(miral-shell
     miral-spinner
     miral
+    ${FREETYPE_LIBRARIES}
 )
 
 install(TARGETS miral-shell

=== modified file 'miral-shell/decoration_provider.cpp'
--- miral-shell/decoration_provider.cpp	2017-03-30 14:12:50 +0000
+++ miral-shell/decoration_provider.cpp	2017-06-20 16:14:05 +0000
@@ -66,10 +66,8 @@
     FT_Face face;
 };
 
-void paint_surface(MirWindow* surface, std::string const& title, int const intensity)
+void paint_surface(MirBufferStream* buffer_stream, std::string const& title, int const intensity)
 {
-    MirBufferStream* buffer_stream = mir_window_get_buffer_stream(surface);
-
     // TODO sometimes buffer_stream is nullptr - find out why (and fix).
     // (Only observed when creating a lot of clients at once)
     if (!buffer_stream)
@@ -286,11 +284,6 @@
         {
             if (connection)
             {
-#if MIR_CLIENT_API_VERSION < MIR_VERSION_NUMBER(0, 26, 2)
-                auto const Workaround_lp_1667645 =
-                     WindowSpec::for_normal_window(connection, 100, 100, mir_pixel_format_xrgb_8888)
-                         .set_name(wallpaper_name).create_window();
-#endif
                 wallpaper.erase(begin(wallpaper), end(wallpaper));
             }
             connection.reset();
@@ -326,24 +319,36 @@
     DisplayConfig const display_conf{this->connection};
 
     display_conf.for_each_output([this](MirOutput const* output)
-         {
-             wallpaper.push_back(
-                 WindowSpec::for_gloss(this->connection, 100, 100)
-                     .set_pixel_format(mir_pixel_format_xrgb_8888)
-                     .set_buffer_usage(mir_buffer_usage_software)
-                     .set_fullscreen_on_output(mir_output_get_id(output))
-                     .set_name(wallpaper_name).create_window());
-
-             MirGraphicsRegion graphics_region;
-             MirBufferStream* buffer_stream = mir_window_get_buffer_stream(wallpaper.back());
-
-             mir_buffer_stream_get_graphics_region(buffer_stream, &graphics_region);
-
-             static uint8_t const pattern[4] = { 0x00, 0x00, 0x00, 0x00 };
-
-             render_pattern(&graphics_region, pattern);
-             mir_buffer_stream_swap_buffers_sync(buffer_stream);
-         });
+        {
+            if (!mir_output_is_enabled(output))
+                return;
+
+            auto const mode = mir_output_get_current_mode(output);
+            auto const output_id = mir_output_get_id(output);
+            auto const width = mir_output_mode_get_width(mode);
+            auto const height = mir_output_mode_get_height(mode);
+
+            Surface surface{mir_connection_create_render_surface_sync(this->connection, width, height)};
+
+            auto const buffer_stream =
+                mir_render_surface_get_buffer_stream(surface, width, height, mir_pixel_format_xrgb_8888);
+
+            auto window = WindowSpec::for_gloss(this->connection, width, height)
+                .set_fullscreen_on_output(output_id)
+                .add_surface(surface, width, height, 0, 0)
+                .set_name(wallpaper_name).create_window();
+
+            wallpaper.push_back(Wallpaper{surface, window, buffer_stream});
+
+            MirGraphicsRegion graphics_region;
+
+            mir_buffer_stream_get_graphics_region(buffer_stream, &graphics_region);
+
+            static uint8_t const pattern[4] = { 0x00, 0x00, 0x00, 0x00 };
+
+            render_pattern(&graphics_region, pattern);
+            mir_buffer_stream_swap_buffers_sync(buffer_stream);
+        });
 
     start_work();
 }
@@ -360,23 +365,54 @@
     return weak_session.lock();
 }
 
+void DecorationProvider::handle_event(MirWindow* window, MirEvent const* ev, void* context_)
+{
+    auto* const context = (Data*)context_;
+
+    switch (mir_event_get_type(ev))
+    {
+    case mir_event_type_resize:
+    {
+        MirResizeEvent const* resize = mir_event_get_resize_event(ev);
+        int const new_width = mir_resize_event_get_width(resize);
+        int const new_height = mir_resize_event_get_height(resize);
+        mir_render_surface_set_size(context->surface, new_width, new_height);
+        WindowSpec::for_changes(context->connection)
+            .add_surface(context->surface, new_width, new_height, 0, 0)
+            .apply_to(window);
+        break;
+    }
+
+    default:
+        break;
+    }
+}
+
 void DecorationProvider::create_titlebar_for(miral::Window const& window)
 {
+    if (is_decoration(window)) return;
+
     enqueue_work([this, window]
         {
+            auto const width = window.size().width.as_int();
             std::ostringstream buffer;
-
             buffer << std::shared_ptr<mir::scene::Surface>(window).get();
 
-            auto const spec = WindowSpec::for_normal_window(
-                connection, window.size().width.as_int(), title_bar_height, mir_pixel_format_xrgb_8888)
-                .set_buffer_usage(mir_buffer_usage_software)
-                .set_type(mir_window_type_gloss)
-                .set_name(buffer.str().c_str());
+            Surface surface{mir_connection_create_render_surface_sync(this->connection, width, title_bar_height)};
 
             std::lock_guard<decltype(mutex)> lock{mutex};
+
+            auto const data = &window_to_titlebar[window];
+            data->connection = connection;
+            data->surface = surface;
+            data->stream = mir_render_surface_get_buffer_stream(surface, width, title_bar_height, mir_pixel_format_xrgb_8888);
             windows_awaiting_titlebar[buffer.str()] = window;
-            spec.create_window(insert, &window_to_titlebar[window]);
+
+            WindowSpec::for_gloss(connection, width, title_bar_height)
+                .add_surface(surface, width, title_bar_height, 0, 0)
+                .set_name(buffer.str().c_str())
+                .set_event_handler(&handle_event, data)
+                .create_window(insert, data);
         });
 }
 
@@ -388,15 +424,7 @@
 
         auto const title = info.name();
 
-        if (auto surface = data->titlebar.load())
-        {
-            enqueue_work([this, surface, title, intensity]{ paint_surface(surface, title, intensity); });
-        }
-        else
-        {
-            data->on_create = [this, title, intensity](MirWindow* surface)
-                { enqueue_work([this, surface, title, intensity]{ paint_surface(surface, title, intensity); }); };
-        }
+        enqueue_work([this, stream=data->stream, title, intensity]{ paint_surface(stream, title, intensity); });
     }
 }
 
@@ -511,11 +539,8 @@
     {
         auto const title = window_info.name();
 
-        if (auto surface = data->titlebar.load())
-        {
-            enqueue_work([this, surface, title, intensity=data->intensity.load()]
-                             { paint_surface(surface, title, intensity); });
-        }
+        enqueue_work([this, stream=data->stream, title, intensity=data->intensity.load()]
+            { paint_surface(stream, title, intensity); });
     }
 }
 

=== modified file 'miral-shell/decoration_provider.h'
--- miral-shell/decoration_provider.h	2017-03-01 14:02:59 +0000
+++ miral-shell/decoration_provider.h	2017-06-20 16:14:05 +0000
@@ -23,6 +23,7 @@
 #include <miral/window_manager_tools.h>
 
 #include <mir/client/connection.h>
+#include <mir/client/surface.h>
 #include <mir/client/window.h>
 
 #include <mir/geometry/rectangle.h>
@@ -81,6 +82,9 @@
 private:
     struct Data
     {
+        MirConnection* connection{nullptr};
+        mir::client::Surface surface;
+        MirBufferStream* stream{nullptr};
         std::atomic<MirWindow*> titlebar{nullptr};
         std::atomic<int> intensity{0xff};
         std::function<void(MirWindow* surface)> on_create{[](MirWindow*){}};
@@ -95,7 +99,8 @@
     miral::WindowManagerTools tools;
     std::mutex mutable mutex;
     mir::client::Connection connection;
-    std::vector<mir::client::Window> wallpaper;
+    struct Wallpaper { mir::client::Surface surface; mir::client::Window window; MirBufferStream* stream; };
+    std::vector<Wallpaper> wallpaper;
     std::weak_ptr<mir::scene::Session> weak_session;
 
     SurfaceMap window_to_titlebar;
@@ -105,6 +110,7 @@
     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);
+    static void handle_event(MirWindow* window, MirEvent const* ev, void* context_);
 };
 
 

=== renamed file 'miral-shell/titlebar_window_manager.cpp' => 'miral-shell/floating_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	2017-03-20 10:57:31 +0000
+++ miral-shell/floating_window_manager.cpp	2017-06-20 16:14:05 +0000
@@ -16,7 +16,7 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#include "titlebar_window_manager.h"
+#include "floating_window_manager.h"
 #include "decoration_provider.h"
 
 #include <miral/application_info.h>
@@ -46,7 +46,7 @@
 }
 }
 
-TitlebarWindowManagerPolicy::TitlebarWindowManagerPolicy(
+FloatingWindowManagerPolicy::FloatingWindowManagerPolicy(
     WindowManagerTools const& tools,
     SpinnerSplash const& spinner,
     miral::InternalClientLauncher const& launcher,
@@ -64,9 +64,9 @@
     active_workspace = key_to_workspace[KEY_F1];
 }
 
-TitlebarWindowManagerPolicy::~TitlebarWindowManagerPolicy() = default;
+FloatingWindowManagerPolicy::~FloatingWindowManagerPolicy() = default;
 
-bool TitlebarWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
+bool FloatingWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
 {
     auto const action = mir_pointer_event_action(event);
     auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
@@ -137,7 +137,7 @@
     return consumes_event;
 }
 
-void TitlebarWindowManagerPolicy::end_resize()
+void FloatingWindowManagerPolicy::end_resize()
 {
     if (!resizing  && !pinching)
         return;
@@ -160,7 +160,7 @@
     pinching = false;
 }
 
-bool TitlebarWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
+bool FloatingWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
 {
     auto const count = mir_touch_event_point_count(event);
 
@@ -281,7 +281,7 @@
     return consumes_event;
 }
 
-void TitlebarWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
+void FloatingWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
 {
     CanonicalWindowManagerPolicy::advise_new_window(window_info);
 
@@ -306,7 +306,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
+void FloatingWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
 {
     if (window_info.window().application() != spinner.session() && window_info.needs_titlebar(window_info.type()))
         decoration_provider->create_titlebar_for(window_info.window());
@@ -314,14 +314,14 @@
     CanonicalWindowManagerPolicy::handle_window_ready(window_info);
 }
 
-void TitlebarWindowManagerPolicy::advise_focus_lost(WindowInfo const& info)
+void FloatingWindowManagerPolicy::advise_focus_lost(WindowInfo const& info)
 {
     CanonicalWindowManagerPolicy::advise_focus_lost(info);
 
     decoration_provider->paint_titlebar_for(info, 0x3F);
 }
 
-void TitlebarWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
+void FloatingWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
     CanonicalWindowManagerPolicy::advise_focus_gained(info);
 
@@ -337,28 +337,28 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirWindowState state)
+void FloatingWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirWindowState state)
 {
     CanonicalWindowManagerPolicy::advise_state_change(window_info, state);
 
     decoration_provider->advise_state_change(window_info, state);
 }
 
-void TitlebarWindowManagerPolicy::advise_resize(WindowInfo const& window_info, Size const& new_size)
+void FloatingWindowManagerPolicy::advise_resize(WindowInfo const& window_info, Size const& new_size)
 {
     CanonicalWindowManagerPolicy::advise_resize(window_info, new_size);
 
     decoration_provider->resize_titlebar_for(window_info, new_size);
 }
 
-void TitlebarWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
+void FloatingWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
 {
     CanonicalWindowManagerPolicy::advise_delete_window(window_info);
 
     decoration_provider->destroy_titlebar_for(window_info.window());
 }
 
-bool TitlebarWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
+bool FloatingWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
 {
     auto const action = mir_keyboard_event_action(event);
     auto const scan_code = mir_keyboard_event_scan_code(event);
@@ -514,7 +514,7 @@
     return false;
 }
 
-void TitlebarWindowManagerPolicy::toggle(MirWindowState state)
+void FloatingWindowManagerPolicy::toggle(MirWindowState state)
 {
     if (auto const window = tools.active_window())
     {
@@ -528,7 +528,7 @@
     }
 }
 
-bool TitlebarWindowManagerPolicy::resize(Window const& window, Point cursor, Point old_cursor)
+bool FloatingWindowManagerPolicy::resize(Window const& window, Point cursor, Point old_cursor)
 {
     if (!window)
         return false;
@@ -579,7 +579,7 @@
     return true;
 }
 
-void TitlebarWindowManagerPolicy::keep_size_within_limits(
+void FloatingWindowManagerPolicy::keep_size_within_limits(
     WindowInfo const& window_info, Displacement& delta, Width& new_width, Height& new_height) const
 {
     auto const min_width  = std::max(window_info.min_width(), Width{5});
@@ -617,7 +617,7 @@
     }
 }
 
-WindowSpecification TitlebarWindowManagerPolicy::place_new_window(
+WindowSpecification FloatingWindowManagerPolicy::place_new_window(
     ApplicationInfo const& app_info, WindowSpecification const& request_parameters)
 {
     auto parameters = CanonicalWindowManagerPolicy::place_new_window(app_info, request_parameters);
@@ -634,7 +634,7 @@
     return parameters;
 }
 
-void TitlebarWindowManagerPolicy::advise_adding_to_workspace(
+void FloatingWindowManagerPolicy::advise_adding_to_workspace(
     std::shared_ptr<Workspace> const& workspace, std::vector<Window> const& windows)
 {
     if (windows.empty())
@@ -653,7 +653,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::switch_workspace_to(
+void FloatingWindowManagerPolicy::switch_workspace_to(
     std::shared_ptr<Workspace> const& workspace,
     Window const& window)
 {
@@ -716,7 +716,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::apply_workspace_hidden_to(Window const& window)
+void FloatingWindowManagerPolicy::apply_workspace_hidden_to(Window const& window)
 {
     auto const& window_info = tools.info_for(window);
     auto& pdata = policy_data_for(window_info);
@@ -732,7 +732,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::apply_workspace_visible_to(Window const& window)
+void FloatingWindowManagerPolicy::apply_workspace_visible_to(Window const& window)
 {
     auto const& window_info = tools.info_for(window);
     auto& pdata = policy_data_for(window_info);
@@ -746,7 +746,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::handle_modify_window(WindowInfo& window_info, WindowSpecification const& modifications)
+void FloatingWindowManagerPolicy::handle_modify_window(WindowInfo& window_info, WindowSpecification const& modifications)
 {
     auto mods = modifications;
 

=== renamed file 'miral-shell/titlebar_window_manager.h' => 'miral-shell/floating_window_manager.h'
--- miral-shell/titlebar_window_manager.h	2017-03-01 14:02:59 +0000
+++ miral-shell/floating_window_manager.h	2017-06-20 16:14:05 +0000
@@ -6,7 +6,7 @@
  * 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
+ * but WITHOUT ANY WARRANTY; without even the implied warranty ofb
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
@@ -16,8 +16,8 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#ifndef MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H
-#define MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H
+#ifndef MIRAL_SHELL_FLOATING_WINDOW_MANAGER_H
+#define MIRAL_SHELL_FLOATING_WINDOW_MANAGER_H
 
 #include <miral/canonical_window_manager.h>
 #include <miral/workspace_policy.h>
@@ -33,15 +33,15 @@
 
 class DecorationProvider;
 
-class TitlebarWindowManagerPolicy : public miral::CanonicalWindowManagerPolicy, miral::WorkspacePolicy
+class FloatingWindowManagerPolicy : public miral::CanonicalWindowManagerPolicy, miral::WorkspacePolicy
 {
 public:
-    TitlebarWindowManagerPolicy(
+    FloatingWindowManagerPolicy(
         miral::WindowManagerTools const& tools,
         SpinnerSplash const& spinner,
         miral::InternalClientLauncher const& launcher,
         std::function<void()>& shutdown_hook);
-    ~TitlebarWindowManagerPolicy();
+    ~FloatingWindowManagerPolicy();
 
     virtual miral::WindowSpecification place_new_window(
         miral::ApplicationInfo const& app_info, miral::WindowSpecification const& request_parameters) override;
@@ -133,4 +133,4 @@
     void apply_workspace_hidden_to(miral::Window const& window);
 };
 
-#endif //MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H
+#endif //MIRAL_SHELL_FLOATING_WINDOW_MANAGER_H

=== modified file 'miral-shell/miral-app.sh'
--- miral-shell/miral-app.sh	2017-03-24 14:54:48 +0000
+++ miral-shell/miral-app.sh	2017-06-20 16:14:05 +0000
@@ -46,6 +46,6 @@
 while [ ! -e "${socket}" ]; do echo "waiting for ${socket}"; sleep 1 ;done
 
 unset QT_QPA_PLATFORMTHEME
-MIR_SOCKET=${socket} GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir dbus-run-session -- ${launcher}
+MIR_SOCKET=${socket} XDG_SESSION_TYPE=mir GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir dbus-run-session -- ${launcher}
 killall ${bindir}${miral_server}
 

=== modified file 'miral-shell/miral-desktop.sh'
--- miral-shell/miral-desktop.sh	2017-03-24 14:54:48 +0000
+++ miral-shell/miral-desktop.sh	2017-06-20 16:14:05 +0000
@@ -40,6 +40,6 @@
 while [ ! -e "${socket}" ]; do echo "waiting for ${socket}"; sleep 1 ;done
 
 unset QT_QPA_PLATFORMTHEME
-MIR_SOCKET=${socket} GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir dbus-run-session -- ${launcher}
+MIR_SOCKET=${socket} XDG_SESSION_TYPE=mir GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir dbus-run-session -- ${launcher}
 sudo killall ${bindir}${miral_server}
 

=== modified file 'miral-shell/miral-run.sh'
--- miral-shell/miral-run.sh	2017-03-24 14:54:48 +0000
+++ miral-shell/miral-run.sh	2017-06-20 16:14:05 +0000
@@ -3,4 +3,4 @@
 then extras='--app-id com.canonical.miral.Terminal'
 fi
 unset QT_QPA_PLATFORMTHEME
-MIR_SOCKET=${XDG_RUNTIME_DIR}/miral_socket GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir "$@" ${extras}&
+MIR_SOCKET=${XDG_RUNTIME_DIR}/miral_socket XDG_SESSION_TYPE=mir GDK_BACKEND=mir QT_QPA_PLATFORM=ubuntumirclient SDL_VIDEODRIVER=mir "$@" ${extras}&

=== modified file 'miral-shell/miral-screencast.sh'
--- miral-shell/miral-screencast.sh	2016-12-09 11:08:07 +0000
+++ miral-shell/miral-screencast.sh	2017-06-20 16:14:05 +0000
@@ -2,7 +2,7 @@
 width=1920
 height=1080
 output=screencast.mp4
-socket=${XDG_RUNTIME_DIR}/mir_socket
+socket=${XDG_RUNTIME_DIR}/miral_socket
 if [ -v MIR_SERVER ]; then socket=${MIR_SERVER}; fi
 
 while [ $# -gt 0 ]

=== modified file 'miral-shell/miral-xrun.sh'
--- miral-shell/miral-xrun.sh	2017-03-24 15:47:07 +0000
+++ miral-shell/miral-xrun.sh	2017-06-20 16:14:05 +0000
@@ -21,6 +21,7 @@
     exit 0
   elif [ "$1" == "-force" ];
   then
+    export XDG_SESSION_TYPE=x11
     export GDK_BACKEND=x11
     export QT_QPA_PLATFORM=xcb
     export SDL_VIDEODRIVER=x11

=== modified file 'miral-shell/shell_main.cpp'
--- miral-shell/shell_main.cpp	2017-03-06 09:45:37 +0000
+++ miral-shell/shell_main.cpp	2017-06-20 16:14:05 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "tiling_window_manager.h"
-#include "titlebar_window_manager.h"
+#include "floating_window_manager.h"
 #include "titlebar_config.h"
 #include "spinner/splash.h"
 
@@ -44,7 +44,7 @@
     ActiveOutputsMonitor outputs_monitor;
     WindowManagerOptions window_managers
         {
-            add_window_manager_policy<TitlebarWindowManagerPolicy>("titlebar", spinner, launcher, shutdown_hook),
+            add_window_manager_policy<FloatingWindowManagerPolicy>("floating", spinner, launcher, shutdown_hook),
             add_window_manager_policy<TilingWindowManagerPolicy>("tiling", spinner, launcher, outputs_monitor),
         };
 
@@ -83,7 +83,7 @@
         {
             CommandLineOption{[&](std::string const& ) { },
                               "desktop_file_hint", "Ignored for Unity8 compatibility", "miral-shell.desktop"},
-            CursorTheme{"default"},
+            CursorTheme{"DMZ-White"},
             window_managers,
             display_configuration_options,
             launcher,

=== modified file 'miral-shell/spinner/CMakeLists.txt'
--- miral-shell/spinner/CMakeLists.txt	2016-05-20 09:20:19 +0000
+++ miral-shell/spinner/CMakeLists.txt	2017-06-20 16:14:05 +0000
@@ -59,6 +59,7 @@
 )
 
 target_link_libraries(miral-spinner
+  mirclientcpp
   EGL
   ${GLIB_LDFLAGS}
   ${GLESv2_LIBRARIES}

=== modified file 'miral-shell/spinner/eglapp.cpp'
--- miral-shell/spinner/eglapp.cpp	2017-01-19 15:13:51 +0000
+++ miral-shell/spinner/eglapp.cpp	2017-06-20 16:14:05 +0000
@@ -16,61 +16,16 @@
 
 #include "eglapp.h"
 
+#include <mir/client/display_config.h>
+
 #include "miregl.h"
 
-#include <mir_toolkit/version.h>
-
 
 float mir_eglapp_background_opacity = 1.0f;
 
 
 namespace
 {
-template<typename ActiveOutputHandler>
-void for_each_active_output(
-    MirConnection* const connection, ActiveOutputHandler const& handler)
-{
-    /* 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);
-
-    for (MirDisplayOutput* output = display_config->outputs;
-         output != display_config->outputs + display_config->num_outputs;
-         ++output)
-    {
-        if (output->used &&
-            output->connected &&
-            output->num_modes &&
-            output->current_mode < output->num_modes)
-        {
-            handler(output);
-        }
-    }
-
-    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)
 {
     unsigned int format[mir_pixel_formats];
@@ -93,69 +48,33 @@
 
 std::vector<std::shared_ptr<MirEglSurface>> mir_eglapp_init(MirConnection* const connection)
 {
-    MirWindowParameters surfaceparm =
-        {
-            "eglappsurface",
-            0, 0,
-            mir_pixel_format_xbgr_8888,
-            mir_buffer_usage_hardware,
-            mir_display_output_id_invalid
-        };
-
-    EGLint swapinterval = 1;
+    char const * const name = "eglappsurface";
 
     if (!mir_connection_is_valid(connection))
         throw std::runtime_error("Can't get connection");
 
     auto const pixel_format = select_pixel_format(connection);
-    surfaceparm.pixel_format = pixel_format;
 
     auto const mir_egl_app = make_mir_eglapp(connection, pixel_format);
 
     std::vector<std::shared_ptr<MirEglSurface>> result;
 
-    // If a size has been specified just do that
-    if (surfaceparm.width && surfaceparm.height)
-    {
-        result.push_back(std::make_shared<MirEglSurface>(mir_egl_app, surfaceparm, swapinterval));
-        return result;
-    }
-
-    // If an output has been specified just do that
-    if (surfaceparm.output_id != mir_display_output_id_invalid)
-    {
-        result.push_back(std::make_shared<MirEglSurface>(mir_egl_app, surfaceparm, swapinterval));
-        return result;
-    }
-
-    // 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];
-
-            printf("Active output [%u] at (%d, %d) is %dx%d\n",
-                   output->output_id,
-                   output->position_x, output->position_y,
-                   mode.horizontal_resolution, mode.vertical_resolution);
-
-            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
+    mir::client::DisplayConfig{connection}.for_each_output([&](MirOutput const* output)
+        {
+            if (mir_output_get_connection_state(output) == mir_output_connection_state_connected &&
+                mir_output_is_enabled(output))
+            {
+                auto const mode = mir_output_get_current_mode(output);
+                auto const output_id = mir_output_get_id(output);
+
+                printf("Active output [%u] at (%d, %d) is %dx%d\n",
+                       output_id,
+                       mir_output_get_position_x(output), mir_output_get_position_y(output),
+                       mir_output_mode_get_width(mode), mir_output_mode_get_height(mode));
+
+                result.push_back(std::make_shared<MirEglSurface>(mir_egl_app, name, output));
+            }
+        });
 
     if (result.empty())
         throw std::runtime_error("No active outputs found.");

=== modified file 'miral-shell/spinner/eglspinner.cpp'
--- miral-shell/spinner/eglspinner.cpp	2016-04-17 00:20:00 +0000
+++ miral-shell/spinner/eglspinner.cpp	2017-06-20 16:14:05 +0000
@@ -34,6 +34,8 @@
 #include <atomic>
 #include <mutex>
 
+#include <mir_toolkit/mir_client_library.h>
+
 #include "spinner_glow.h"
 #include "spinner_logo.h"
 

=== modified file 'miral-shell/spinner/miregl.cpp'
--- miral-shell/spinner/miregl.cpp	2017-02-14 11:49:59 +0000
+++ miral-shell/spinner/miregl.cpp	2017-06-20 16:14:05 +0000
@@ -15,21 +15,22 @@
  */
 
 #include "miregl.h"
+#include <miral/window_specification.h>
 #include <mir/client/window_spec.h>
-#include <mir_toolkit/version.h>
+#include <mir_toolkit/mir_client_library.h>
 
 #include <cstring>
 
 #include <GLES2/gl2.h>
-#include <miral/window_specification.h>
-#include <mir/client/window_spec.h>
+
+using namespace mir::client;
 
 class MirEglApp
 {
 public:
     MirEglApp(MirConnection* const connection, MirPixelFormat pixel_format);
 
-    EGLSurface create_surface(MirWindow* window);
+    EGLSurface create_surface(MirRenderSurface* surface);
 
     void make_current(EGLSurface eglsurface) const;
 
@@ -60,47 +61,37 @@
     return std::make_shared<MirEglApp>(connection, pixel_format);
 }
 
-namespace
-{
-MirWindow* create_window(MirConnection* const connection, MirWindowParameters const& parameters)
-{
-
-    auto spec = mir::client::WindowSpec::for_normal_window(
-        connection, parameters.width, parameters.height, parameters.pixel_format)
-        .set_name(parameters.name)
-        .set_buffer_usage(parameters.buffer_usage);
-
-
-    if (!parameters.width && !parameters.height)
-        spec.set_fullscreen_on_output(parameters.output_id);
-
-    auto const window = mir_create_window_sync(spec);
+MirEglSurface::MirEglSurface(
+    std::shared_ptr<MirEglApp> const& mir_egl_app,
+    char const* name,
+    MirOutput const* output)
+:
+    mir_egl_app{mir_egl_app}
+{
+    auto const mode = mir_output_get_current_mode(output);
+    auto const output_id = mir_output_get_id(output);
+    auto const width = mir_output_mode_get_width(mode);
+    auto const height = mir_output_mode_get_height(mode);
+
+    surface = Surface{mir_connection_create_render_surface_sync(mir_egl_app->connection, width, height)};
+
+    eglsurface = mir_egl_app->create_surface(surface);
+
+    window = WindowSpec::for_normal_window(mir_egl_app->connection, width, height)
+        .add_surface(surface, width, height, 0, 0)
+        .set_name(name)
+        .set_fullscreen_on_output(output_id)
+        .create_window();
 
     if (!mir_window_is_valid(window))
         throw std::runtime_error(std::string("Can't create a window ") + mir_window_get_error_message(window));
 
-    if (parameters.output_id != mir_display_output_id_invalid)
-        mir_window_set_state(window, mir_window_state_fullscreen);
-
-    return window;
-}
-}
-
-MirEglSurface::MirEglSurface(
-    std::shared_ptr<MirEglApp> const& mir_egl_app, MirWindowParameters const& parm, int swapinterval) :
-    mir_egl_app{mir_egl_app},
-    window{create_window(mir_egl_app->connection, parm)},
-    eglsurface{mir_egl_app->create_surface(window)},
-    width_{0},
-    height_{0}
-{
-    mir_egl_app->set_swap_interval(eglsurface, swapinterval);
+    mir_egl_app->set_swap_interval(eglsurface, -1);
 }
 
 MirEglSurface::~MirEglSurface()
 {
     mir_egl_app->destroy_surface(eglsurface);
-    mir_window_release_sync(window);
 }
 
 void MirEglSurface::egl_make_current()
@@ -139,7 +130,7 @@
             EGL_NONE
         };
 
-    egldisplay = eglGetDisplay((EGLNativeDisplayType) mir_connection_get_egl_native_display(connection));
+    egldisplay = eglGetDisplay((EGLNativeDisplayType)(connection));
     if (egldisplay == EGL_NO_DISPLAY)
         throw std::runtime_error("Can't eglGetDisplay");
 
@@ -184,12 +175,12 @@
     make_current(dummy_surface);
 }
 
-EGLSurface MirEglApp::create_surface(MirWindow* window)
+EGLSurface MirEglApp::create_surface(MirRenderSurface* surface)
 {
     auto const eglsurface = eglCreateWindowSurface(
         egldisplay,
         eglconfig,
-        (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window(mir_window_get_buffer_stream(window)), NULL);
+        (EGLNativeWindowType)surface, NULL);
 
     if (eglsurface == EGL_NO_SURFACE)
         throw std::runtime_error("eglCreateWindowSurface failed");

=== modified file 'miral-shell/spinner/miregl.h'
--- miral-shell/spinner/miregl.h	2017-03-06 09:49:23 +0000
+++ miral-shell/spinner/miregl.h	2017-06-20 16:14:05 +0000
@@ -17,9 +17,8 @@
 #ifndef UNITYSYSTEMCOMPOSITOR_MIREGL_H
 #define UNITYSYSTEMCOMPOSITOR_MIREGL_H
 
-#include <mir/client/detail/mir_forward_compatibility.h>
-#include <mir_toolkit/client_types.h>
-#include "mir_toolkit/mir_client_library.h"
+#include <mir/client/surface.h>
+#include <mir/client/window.h>
 
 #include <EGL/egl.h>
 
@@ -37,8 +36,8 @@
 public:
     MirEglSurface(
         std::shared_ptr<MirEglApp> const& mir_egl_app,
-        MirWindowParameters const& parm,
-        int swapinterval);
+        char const* name,
+        MirOutput const* output);
 
     ~MirEglSurface();
 
@@ -58,8 +57,9 @@
     unsigned int height() const;
 
     std::shared_ptr<MirEglApp> const mir_egl_app;
-    MirWindow* const window;
-    EGLSurface const eglsurface;
+    mir::client::Surface surface;
+    mir::client::Window window;
+    EGLSurface eglsurface;
     int width_;
     int height_;
 };

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2017-03-20 12:28:06 +0000
+++ miral/CMakeLists.txt	2017-06-20 16:14:05 +0000
@@ -1,4 +1,4 @@
-pkg_check_modules(MIRSERVER mirserver>=0.20 REQUIRED)
+pkg_check_modules(MIRSERVER mirserver>=0.26 REQUIRED)
 
 if(${CMAKE_COMPILER_IS_GNUCXX})
     set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -flto")
@@ -11,8 +11,9 @@
 
 set(MIRAL_ABI 2)
 set(symbol_map ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map)
+set(miral_include ${PROJECT_SOURCE_DIR}/include)
 
-include_directories(include SYSTEM ${MIRSERVER_INCLUDE_DIRS})
+add_library(mirclientcpp INTERFACE)
 
 add_library(miral-internal STATIC
     basic_window_manager.cpp            basic_window_manager.h window_manager_tools_implementation.h
@@ -28,39 +29,53 @@
 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
-    add_init_callback.cpp               ${CMAKE_SOURCE_DIR}/include/miral/add_init_callback.h
-    application.cpp                     ${CMAKE_SOURCE_DIR}/include/miral/application.h
-    application_authorizer.cpp          ${CMAKE_SOURCE_DIR}/include/miral/application_authorizer.h
-    application_info.cpp                ${CMAKE_SOURCE_DIR}/include/miral/application_info.h
-    canonical_window_manager.cpp        ${CMAKE_SOURCE_DIR}/include/miral/canonical_window_manager.h
-    command_line_option.cpp             ${CMAKE_SOURCE_DIR}/include/miral/command_line_option.h
-    cursor_theme.cpp                    ${CMAKE_SOURCE_DIR}/include/miral/cursor_theme.h
-    debug_extension.cpp                 ${CMAKE_SOURCE_DIR}/include/miral/debug_extension.h
-    keymap.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/keymap.h
-    runner.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/runner.h
-    display_configuration_option.cpp    ${CMAKE_SOURCE_DIR}/include/miral/display_configuration_option.h
-    output.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/output.h
-    append_event_filter.cpp             ${CMAKE_SOURCE_DIR}/include/miral/append_event_filter.h
-    window.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/window.h
-    window_info.cpp                     ${CMAKE_SOURCE_DIR}/include/miral/window_info.h
-    window_management_options.cpp       ${CMAKE_SOURCE_DIR}/include/miral/window_management_options.h
-    window_specification.cpp            ${CMAKE_SOURCE_DIR}/include/miral/window_specification.h
-    internal_client.cpp                 ${CMAKE_SOURCE_DIR}/include/miral/internal_client.h
-    set_command_line_handler.cpp        ${CMAKE_SOURCE_DIR}/include/miral/set_command_line_handler.h
-    set_terminator.cpp                  ${CMAKE_SOURCE_DIR}/include/miral/set_terminator.h
-    set_window_management_policy.cpp    ${CMAKE_SOURCE_DIR}/include/miral/set_window_management_policy.h
-    workspace_policy.cpp                ${CMAKE_SOURCE_DIR}/include/miral/workspace_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/mir/client/blob.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/cookie.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/window_spec.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/window_id.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/connection.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/display_config.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/window.h
-                                        ${CMAKE_SOURCE_DIR}/include/mir/client/detail/mir_forward_compatibility.h
+    active_outputs.cpp                  ${miral_include}/miral/active_outputs.h
+    add_init_callback.cpp               ${miral_include}/miral/add_init_callback.h
+    application.cpp                     ${miral_include}/miral/application.h
+    application_authorizer.cpp          ${miral_include}/miral/application_authorizer.h
+    application_info.cpp                ${miral_include}/miral/application_info.h
+    canonical_window_manager.cpp        ${miral_include}/miral/canonical_window_manager.h
+    command_line_option.cpp             ${miral_include}/miral/command_line_option.h
+    cursor_theme.cpp                    ${miral_include}/miral/cursor_theme.h
+    debug_extension.cpp                 ${miral_include}/miral/debug_extension.h
+    keymap.cpp                          ${miral_include}/miral/keymap.h
+    runner.cpp                          ${miral_include}/miral/runner.h
+    display_configuration_option.cpp    ${miral_include}/miral/display_configuration_option.h
+    output.cpp                          ${miral_include}/miral/output.h
+    append_event_filter.cpp             ${miral_include}/miral/append_event_filter.h
+    window.cpp                          ${miral_include}/miral/window.h
+    window_info.cpp                     ${miral_include}/miral/window_info.h
+    window_management_options.cpp       ${miral_include}/miral/window_management_options.h
+    window_specification.cpp            ${miral_include}/miral/window_specification.h
+    internal_client.cpp                 ${miral_include}/miral/internal_client.h
+    set_command_line_handler.cpp        ${miral_include}/miral/set_command_line_handler.h
+    set_terminator.cpp                  ${miral_include}/miral/set_terminator.h
+    set_window_management_policy.cpp    ${miral_include}/miral/set_window_management_policy.h
+    workspace_policy.cpp                ${miral_include}/miral/workspace_policy.h
+    window_management_policy.cpp        ${miral_include}/miral/window_management_policy.h
+    window_manager_tools.cpp            ${miral_include}/miral/window_manager_tools.h
+                                        ${miral_include}/miral/window_management_policy_addendum2.h
+                                        ${miral_include}/mir/client/blob.h
+                                        ${miral_include}/mir/client/cookie.h
+                                        ${miral_include}/mir/client/window_spec.h
+                                        ${miral_include}/mir/client/window_id.h
+                                        ${miral_include}/mir/client/connection.h
+                                        ${miral_include}/mir/client/display_config.h
+                                        ${miral_include}/mir/client/window.h
+)
+
+target_include_directories(mirclientcpp
+    INTERFACE "${miral_include}" ${MIRCLIENT_INCLUDE_DIRS}
+)
+
+target_include_directories(miral-internal
+    PRIVATE "${miral_include}" ${MIRCLIENT_INCLUDE_DIRS}
+    PRIVATE ${MIRSERVER_INCLUDE_DIRS}
+)
+
+target_include_directories(miral
+    PUBLIC  "${miral_include}" ${MIRCLIENT_INCLUDE_DIRS}
+    PRIVATE ${MIRSERVER_INCLUDE_DIRS}
 )
 
 target_link_libraries(miral
@@ -99,26 +114,9 @@
     @ONLY
 )
 
-if (MIRSERVER_VERSION VERSION_LESS 0.24)
-    set(MIR_POINTER_CONFINEMENT 0)
-else()
-    set(MIR_POINTER_CONFINEMENT 1)
-endif()
-
-if (MIRSERVER_VERSION VERSION_LESS 0.22)
-    set(MIR_DISPLAY_CONFIG_GET_MUTABLE 0)
-else()
-    set(MIR_DISPLAY_CONFIG_GET_MUTABLE 1)
-endif()
-
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/mir_features.h.in
-    ${PROJECT_SOURCE_DIR}/include/mir/client/detail/mir_features.h
-)
-
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/version.h.in
-  ${PROJECT_SOURCE_DIR}/include/miral/version.h
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/version.h.in
+    ${miral_include}/miral/version.h
 )
 
 install(TARGETS     miral                           LIBRARY         DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}")

=== modified file 'miral/active_outputs.cpp'
--- miral/active_outputs.cpp	2017-01-13 18:17:01 +0000
+++ miral/active_outputs.cpp	2017-06-20 16:14:05 +0000
@@ -23,12 +23,8 @@
 #include <mir/graphics/display_configuration.h>
 #include <mir/server.h>
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 26, 0)
-#include <mir/graphics/display_configuration_report.h>
-#else
 #include <mir/graphics/display_configuration_observer.h>
 #include <mir/observer_registrar.h>
-#endif
 
 #include <algorithm>
 #include <mutex>
@@ -40,17 +36,6 @@
 void miral::ActiveOutputsListener::advise_output_update(Output const& /*updated*/, Output const& /*original*/) {}
 void miral::ActiveOutputsListener::advise_output_delete(Output const& /*output*/) {}
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 26, 0)
-struct miral::ActiveOutputsMonitor::Self : mir::graphics::DisplayConfigurationReport
-{
-    virtual void initial_configuration(mir::graphics::DisplayConfiguration const& configuration) override;
-    virtual void new_configuration(mir::graphics::DisplayConfiguration const& configuration) override;
-
-    std::mutex mutex;
-    std::vector<ActiveOutputsListener*> listeners;
-    std::vector<Output> outputs;
-};
-#else
 struct miral::ActiveOutputsMonitor::Self : mir::graphics::DisplayConfigurationObserver
 {
     void initial_configuration(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& configuration) override;
@@ -79,7 +64,6 @@
     std::vector<ActiveOutputsListener*> listeners;
     std::vector<Output> outputs;
 };
-#endif
 
 miral::ActiveOutputsMonitor::ActiveOutputsMonitor() :
     self{std::make_shared<Self>()}
@@ -109,12 +93,8 @@
 {
     std::lock_guard<decltype(self->mutex)> lock{self->mutex};
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 26, 0)
-    server.override_the_display_configuration_report([this]{ return self; });
-#else
     server.add_pre_init_callback([this, &server]
         { server.the_display_configuration_observer_registrar()->register_interest(self); });
-#endif
 }
 
 void miral::ActiveOutputsMonitor::process_outputs(
@@ -125,65 +105,11 @@
 }
 
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 26, 0)
-void miral::ActiveOutputsMonitor::Self::initial_configuration(mir::graphics::DisplayConfiguration const& configuration)
-{
-    new_configuration(configuration);
-}
-#else
 void miral::ActiveOutputsMonitor::Self::initial_configuration(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& configuration)
 {
     configuration_applied(configuration);
 }
-#endif
-
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 26, 0)
-void miral::ActiveOutputsMonitor::Self::new_configuration(mir::graphics::DisplayConfiguration const& configuration)
-{
-    std::lock_guard<decltype(mutex)> lock{mutex};
-
-    decltype(outputs) current_outputs;
-
-    for (auto const l : listeners)
-        l->advise_output_begin();
-
-    configuration.for_each_output([&current_outputs, this](mir::graphics::DisplayConfigurationOutput const& output)
-        {
-            Output o{output};
-
-            if (!o.connected() || !o.valid()) return;
-
-            auto op = find_if(begin(outputs), end(outputs), [&](Output const& oo) { return oo.is_same_output(o); });
-
-            if (op == end(outputs))
-            {
-                for (auto const l : listeners)
-                    l->advise_output_create(o);
-            }
-            else if (!equivalent_display_area(o, *op))
-            {
-                for (auto const l : listeners)
-                    l->advise_output_update(o, *op);
-            }
-
-            current_outputs.push_back(o);
-        });
-
-    for (auto const& o : outputs)
-    {
-        auto op = find_if(begin(current_outputs), end(current_outputs), [&](Output const& oo)
-            { return oo.is_same_output(o); });
-
-        if (op == end(current_outputs))
-            for (auto const l : listeners)
-                l->advise_output_delete(o);
-    }
-
-    current_outputs.swap(outputs);
-    for (auto const l : listeners)
-        l->advise_output_end();
-}
-#else
+
 void miral::ActiveOutputsMonitor::Self::configuration_applied(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& config)
 {
     std::lock_guard<decltype(mutex)> lock{mutex};
@@ -233,4 +159,3 @@
     for (auto const l : listeners)
         l->advise_output_end();
 }
-#endif

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2017-03-21 12:30:42 +0000
+++ miral/basic_window_manager.cpp	2017-06-20 16:14:05 +0000
@@ -19,6 +19,7 @@
 #include "basic_window_manager.h"
 #include "miral/window_manager_tools.h"
 #include "miral/workspace_policy.h"
+#include "miral/window_management_policy_addendum2.h"
 
 #include <mir/scene/session.h>
 #include <mir/scene/surface.h>
@@ -70,7 +71,6 @@
 
 namespace
 {
-
 auto find_workspace_policy(std::unique_ptr<miral::WindowManagementPolicy> const& policy) -> miral::WorkspacePolicy*
 {
     miral::WorkspacePolicy* result = dynamic_cast<miral::WorkspacePolicy*>(policy.get());
@@ -82,6 +82,23 @@
 
     return &null_workspace_policy;
 }
+
+auto find_policy_addendum2(std::unique_ptr<miral::WindowManagementPolicy> const& policy) -> miral::WindowManagementPolicyAddendum2*
+{
+    miral::WindowManagementPolicyAddendum2* result = dynamic_cast<miral::WindowManagementPolicyAddendum2*>(policy.get());
+
+    if (result)
+        return result;
+
+    struct NullWindowManagementPolicyAddendum2 : miral::WindowManagementPolicyAddendum2
+    {
+        void handle_request_drag_and_drop(miral::WindowInfo&) override {}
+        void handle_request_move(miral::WindowInfo&, MirInputEvent const*) override {}
+    };
+    static NullWindowManagementPolicyAddendum2 null_workspace_policy;
+
+    return &null_workspace_policy;
+}
 }
 
 
@@ -94,10 +111,18 @@
     display_layout(display_layout),
     persistent_surface_store{persistent_surface_store},
     policy(build(WindowManagerTools{this})),
-    workspace_policy{find_workspace_policy(policy)}
+    workspace_policy{find_workspace_policy(policy)},
+    policy2{find_policy_addendum2(policy)}
 {
 }
 
+miral::BasicWindowManager::~BasicWindowManager()
+{
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+    if (last_input_event)
+        mir_event_unref(last_input_event);
+#endif
+}
 void miral::BasicWindowManager::add_session(std::shared_ptr<scene::Session> const& session)
 {
     Locker lock{this};
@@ -156,14 +181,12 @@
         session,
         scene_surface));
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     if (parent && spec.aux_rect().is_set() && spec.placement_hints().is_set())
     {
         Rectangle relative_placement{window.top_left() - (parent.top_left()-Point{}), window.size()};
         auto const mir_surface = std::shared_ptr<scene::Surface>(window);
         mir_surface->placed_relative(relative_placement);
     }
-#endif
 
     return surface_id;
 }
@@ -362,10 +385,24 @@
 #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
 void miral::BasicWindowManager::handle_request_drag_and_drop(
     std::shared_ptr<mir::scene::Session> const& /*session*/,
-    std::shared_ptr<mir::scene::Surface> const& /*surface*/,
-    uint64_t /*timestamp*/)
-{
-    // TODO
+    std::shared_ptr<mir::scene::Surface> const& surface,
+    uint64_t timestamp)
+{
+    Locker lock{this};
+    if (timestamp >= last_input_event_timestamp)
+        policy2->handle_request_drag_and_drop(info_for(surface));
+}
+
+void miral::BasicWindowManager::handle_request_move(
+    std::shared_ptr<mir::scene::Session> const& /*session*/,
+    std::shared_ptr<mir::scene::Surface> const& surface,
+    uint64_t timestamp)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    if (timestamp >= last_input_event_timestamp && last_input_event)
+    {
+        policy2->handle_request_move(info_for(surface), mir_event_get_input_event(last_input_event));
+    }
 }
 #endif
 
@@ -741,6 +778,24 @@
     focus_controller->raise({begin(windows), end(windows)});
 }
 
+void miral::BasicWindowManager::start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle)
+{
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+    std::shared_ptr<scene::Surface>(window_info.window())->start_drag_and_drop(handle);
+    focus_controller->set_drag_and_drop_handle(handle);
+#else
+    (void)window_info;
+    (void)handle;
+#endif
+}
+
+void miral::BasicWindowManager::end_drag_and_drop()
+{
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+    focus_controller->clear_drag_and_drop_handle();
+#endif
+}
+
 void miral::BasicWindowManager::move_tree(miral::WindowInfo& root, mir::geometry::Displacement movement)
 {
     if (movement == mir::geometry::Displacement{})
@@ -900,11 +955,9 @@
             if (new_pos.is_set())
                 place_and_size(window_info, new_pos.value().top_left, new_pos.value().size);
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
             Rectangle relative_placement{window.top_left() - (parent.top_left()-Point{}), window.size()};
             auto const mir_surface = std::shared_ptr<scene::Surface>(window);
             mir_surface->placed_relative(relative_placement);
-#endif
         }
     }
 
@@ -913,25 +966,18 @@
         set_state(window_info, modifications.state().value());
     }
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
     if (modifications.confine_pointer().is_set())
         std::shared_ptr<scene::Surface>(window)->set_confine_pointer_state(modifications.confine_pointer().value());
-#endif
 }
 
 auto miral::BasicWindowManager::info_for_window_id(std::string const& id) const -> WindowInfo&
 {
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
     auto surface = persistent_surface_store->surface_for_id(mir::shell::PersistentSurfaceStore::Id{id});
 
     if (!surface)
         BOOST_THROW_EXCEPTION(std::runtime_error{"No surface matching ID"});
 
     return info_for(surface);
-#else
-    (void)id;
-    BOOST_THROW_EXCEPTION(std::runtime_error{"No surface matching ID"});
-#endif
 }
 
 auto miral::BasicWindowManager::id_for_window(Window const& window) const -> std::string
@@ -939,11 +985,7 @@
     if (!window)
         BOOST_THROW_EXCEPTION(std::runtime_error{"Null Window has no Persistent ID"});
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
     return persistent_surface_store->id_for_surface(window).serialize_to_string();
-#else
-    BOOST_THROW_EXCEPTION(std::runtime_error{"Persistent IDs unavailable with this Mir server version"});
-#endif
 }
 
 void miral::BasicWindowManager::place_and_size(WindowInfo& root, Point const& new_pos, Size const& new_size)
@@ -1163,25 +1205,22 @@
 
 void miral::BasicWindowManager::update_event_timestamp(MirKeyboardEvent const* kev)
 {
-    auto iev = mir_keyboard_event_input_event(kev);
-    last_input_event_timestamp = mir_input_event_get_event_time(iev);
+    update_event_timestamp(mir_keyboard_event_input_event(kev));
 }
 
 void miral::BasicWindowManager::update_event_timestamp(MirPointerEvent const* pev)
 {
-    auto iev = mir_pointer_event_input_event(pev);
     auto pointer_action = mir_pointer_event_action(pev);
 
     if (pointer_action == mir_pointer_action_button_up ||
         pointer_action == mir_pointer_action_button_down)
     {
-        last_input_event_timestamp = mir_input_event_get_event_time(iev);
+        update_event_timestamp(mir_pointer_event_input_event(pev));
     }
 }
 
 void miral::BasicWindowManager::update_event_timestamp(MirTouchEvent const* tev)
 {
-    auto iev = mir_touch_event_input_event(tev);
     auto touch_count = mir_touch_event_point_count(tev);
     for (unsigned i = 0; i < touch_count; i++)
     {
@@ -1189,12 +1228,22 @@
         if (touch_action == mir_touch_action_up ||
             touch_action == mir_touch_action_down)
         {
-            last_input_event_timestamp = mir_input_event_get_event_time(iev);
+            update_event_timestamp(mir_touch_event_input_event(tev));
             break;
         }
     }
 }
 
+void miral::BasicWindowManager::update_event_timestamp(MirInputEvent const* iev)
+{
+    last_input_event_timestamp = mir_input_event_get_event_time(iev);
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+    if (last_input_event)
+        mir_event_unref(last_input_event);
+    last_input_event = mir_event_ref(mir_input_event_get_event(iev));
+#endif
+}
+
 void miral::BasicWindowManager::invoke_under_lock(std::function<void()> const& callback)
 {
     Locker lock{this};

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2017-03-21 12:30:42 +0000
+++ miral/basic_window_manager.h	2017-06-20 16:14:05 +0000
@@ -46,6 +46,7 @@
 namespace miral
 {
 class WorkspacePolicy;
+class WindowManagementPolicyAddendum2;
 using mir::shell::SurfaceSet;
 using WindowManagementPolicyBuilder =
     std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools const& tools)>;
@@ -61,6 +62,7 @@
         std::shared_ptr<mir::shell::DisplayLayout> const& display_layout,
         std::shared_ptr<mir::shell::PersistentSurfaceStore> const& persistent_surface_store,
         WindowManagementPolicyBuilder const& build);
+    ~BasicWindowManager();
 
     void add_session(std::shared_ptr<mir::scene::Session> const& session) override;
 
@@ -101,6 +103,11 @@
         std::shared_ptr<mir::scene::Session> const& session,
         std::shared_ptr<mir::scene::Surface> const& surface,
         uint64_t timestamp) override;
+
+    void handle_request_move(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        uint64_t timestamp) override;
 #endif
 
     int set_surface_attribute(
@@ -161,6 +168,8 @@
     auto active_display() -> mir::geometry::Rectangle const override;
 
     void raise_tree(Window const& root) override;
+    void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) override;
+    void end_drag_and_drop() override;
 
     void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override;
 
@@ -190,6 +199,7 @@
 
     std::unique_ptr<WindowManagementPolicy> const policy;
     WorkspacePolicy* const workspace_policy;
+    WindowManagementPolicyAddendum2* const policy2;
 
     std::mutex mutex;
     SessionInfoMap app_info;
@@ -197,6 +207,9 @@
     mir::geometry::Rectangles displays;
     mir::geometry::Point cursor;
     uint64_t last_input_event_timestamp{0};
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0)
+    MirEvent const* last_input_event{nullptr};
+#endif
     miral::MRUWindowList mru_active_windows;
     using FullscreenSurfaces = std::set<Window>;
     FullscreenSurfaces fullscreen_surfaces;
@@ -213,6 +226,7 @@
     void update_event_timestamp(MirKeyboardEvent const* kev);
     void update_event_timestamp(MirPointerEvent const* pev);
     void update_event_timestamp(MirTouchEvent const* tev);
+    void update_event_timestamp(MirInputEvent const* iev);
 
     auto can_activate_window_for_session(miral::Application const& session) -> bool;
     auto can_activate_window_for_session_in_workspace(

=== modified file 'miral/both_versions.h'
--- miral/both_versions.h	2017-02-15 12:17:12 +0000
+++ miral/both_versions.h	2017-06-20 16:14:05 +0000
@@ -27,12 +27,7 @@
 #define MIRAL_FAKE_NEW_SYMBOL(old_sym, new_sym)\
     extern "C" __attribute__((alias(#old_sym))) void new_sym();
 
-#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0))
-    #define MIRAL_BOTH_VERSIONS(old_sym, new_sym)\
-    MIRAL_FAKE_OLD_SYMBOL(old_sym, new_sym)
-#else
-    #define MIRAL_BOTH_VERSIONS(old_sym, new_sym)\
-    MIRAL_FAKE_NEW_SYMBOL(old_sym, new_sym)
-#endif
+#define MIRAL_BOTH_VERSIONS(old_sym, new_sym)\
+MIRAL_FAKE_OLD_SYMBOL(old_sym, new_sym)
 
 #endif //MIRAL_BOTH_VERSIONS_H

=== modified file 'miral/cursor_theme.cpp'
--- miral/cursor_theme.cpp	2016-09-28 10:57:41 +0000
+++ miral/cursor_theme.cpp	2017-06-20 16:14:05 +0000
@@ -19,6 +19,7 @@
 #include "miral/cursor_theme.h"
 #include "xcursor_loader.h"
 
+#include <mir/options/option.h>
 #include <mir/server.h>
 #include <mir_toolkit/cursors.h>
 
@@ -43,8 +44,14 @@
 
 void miral::CursorTheme::operator()(mir::Server& server) const
 {
+    static char const* const option = "cursor-theme";
+
+    server.add_configuration_option(option, "Cursor theme (e.g. \"DMZ-Black\")", theme);
+
     server.override_the_cursor_images([&]
         {
+            auto const theme = server.get_options()->get<std::string const>(option);
+
             std::shared_ptr<mi::CursorImages> const xcursor_loader{std::make_shared<XCursorLoader>(theme)};
 
             if (has_default_cursor(*xcursor_loader))

=== modified file 'miral/keymap.cpp'
--- miral/keymap.cpp	2017-01-17 16:42:33 +0000
+++ miral/keymap.cpp	2017-06-20 16:14:05 +0000
@@ -25,13 +25,8 @@
 #include <mir/server.h>
 #include <mir/version.h>
 
-#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
 
 #define MIR_LOG_COMPONENT "miral::Keymap"
 #include <mir/log.h>
@@ -107,7 +102,6 @@
         apply_keymap(keyboard);
     }
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 1)
     void apply_keymap(std::shared_ptr<mir::input::Device> const& keyboard)
     {
         auto const keyboard_config = keyboard->keyboard_configuration();
@@ -115,11 +109,7 @@
 
         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;
@@ -127,12 +117,6 @@
         keymap.options = options;
         keyboard->apply_keyboard_configuration(std::move(keymap));
     }
-#else
-    void apply_keymap(std::shared_ptr<mir::input::Device> const&)
-    {
-        mir::log_warning("Cannot apply keymap - not supported for Mir versions prior to 0.24.1");
-    }
-#endif
 
     void device_removed(std::shared_ptr<mir::input::Device> const& device) override
     {

=== removed file 'miral/mir_features.h.in'
--- miral/mir_features.h.in	2017-02-17 15:06:53 +0000
+++ miral/mir_features.h.in	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-/*
- * Copyright © 2016 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/>.
- */
-
-#ifndef MIRAL_MIR_FEATURES_H
-#define MIRAL_MIR_FEATURES_H
-
-// ============================================================
-// ==>  miral/detail/mir_features.h is generated by cmake.  <==  
-// ==>                    DO NOT EDIT!                      <==
-// ==>            (edit mir_features.h.in instead)          <==
-// ============================================================
-
-#define MIRAL_MIR_DEFINES_POINTER_CONFINEMENT (@MIR_POINTER_CONFINEMENT@)
-#define MIR_DEFINES_DISPLAY_CONFIG_GET_MUTABLE_OUTPUT (@MIR_DISPLAY_CONFIG_GET_MUTABLE@)
-
-#endif // MIRAL_MIR_FEATURES_H

=== modified file 'miral/mru_window_list.cpp'
--- miral/mru_window_list.cpp	2017-02-17 15:23:49 +0000
+++ miral/mru_window_list.cpp	2017-06-20 16:14:05 +0000
@@ -18,7 +18,6 @@
 
 #include "mru_window_list.h"
 
-#include <mir/client/detail/mir_forward_compatibility.h>
 #include <mir/scene/surface.h>
 
 #include <algorithm>

=== modified file 'miral/runner.cpp'
--- miral/runner.cpp	2017-03-02 13:47:28 +0000
+++ miral/runner.cpp	2017-06-20 16:14:05 +0000
@@ -30,10 +30,6 @@
 #include <mutex>
 #include <thread>
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 24, 0)
-#include <csignal>
-#endif
-
 namespace
 {
 inline auto filename(std::string path) -> std::string
@@ -198,9 +194,7 @@
         for (auto& option : options)
             option(*server);
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
         server->add_stop_callback(stop_callback);
-#endif
 
         // Provide the command line and run the server
         server->set_command_line(argc, argv);
@@ -220,10 +214,6 @@
         auto const main_loop = server->the_main_loop();
         main_loop->enqueue(this, start_callback);
 
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 24, 0)
-        main_loop->register_signal_handler({SIGINT, SIGTERM}, [this](int) {stop_callback();});
-#endif
-
         server->run();
     }
 
@@ -282,11 +272,6 @@
 
     if (auto const server = self->weak_server.lock())
     {
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 24, 0)
-        // Before Mir-0.24 we can't intercept all stop() invocations,
-        // but we can deal with the ones we pass on
-        self->stop_callback();
-#endif
         server->stop();
     }
 }

=== modified file 'miral/set_window_management_policy.cpp'
--- miral/set_window_management_policy.cpp	2017-03-22 10:03:25 +0000
+++ miral/set_window_management_policy.cpp	2017-06-20 16:14:05 +0000
@@ -64,11 +64,7 @@
         {
             auto const display_layout = server.the_shell_display_layout();
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
             auto const persistent_surface_store = server.the_persistent_surface_store();
-#else
-            std::shared_ptr<mir::shell::PersistentSurfaceStore> const persistent_surface_store;
-#endif
 
             if (server.get_options()->is_set(trace_option))
             {

=== modified file 'miral/symbols.map'
--- miral/symbols.map	2017-03-15 17:44:36 +0000
+++ miral/symbols.map	2017-06-20 16:14:05 +0000
@@ -401,3 +401,24 @@
     vtable?for?miral::SetWindowManagementPolicy;
   };
 } MIRAL_1.3;
+
+MIRAL_1.4.0 {
+global:
+  extern "C++" {
+    miral::WindowManagementPolicyAddendum2::?WindowManagementPolicyAddendum2*;
+    miral::WindowManagementPolicyAddendum2::WindowManagementPolicyAddendum2*;
+    miral::WindowManagementPolicyAddendum2::operator*;
+    miral::WindowManagerTools::end_drag_and_drop*;
+    miral::WindowManagerTools::start_drag_and_drop*;
+    miral::toolkit::Window::Window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicyAddendum2::?WindowManagementPolicyAddendum2*;
+    typeinfo?for?miral::WindowManagementPolicyAddendum2;
+    typeinfo?for?miral::toolkit::Window;
+    typeinfo?for?miral::toolkit::WindowId;
+    typeinfo?for?miral::toolkit::WindowSpec;
+    vtable?for?miral::WindowManagementPolicyAddendum2;
+    vtable?for?miral::toolkit::Window;
+    vtable?for?miral::toolkit::WindowId;
+    vtable?for?miral::toolkit::WindowSpec;
+  };
+} MIRAL_1.3.1;

=== modified file 'miral/window_management_options.cpp'
--- miral/window_management_options.cpp	2016-09-21 14:43:46 +0000
+++ miral/window_management_options.cpp	2017-06-20 16:14:05 +0000
@@ -56,12 +56,8 @@
             auto const selection = options->get<std::string>(wm_option);
 
             auto const display_layout = server.the_shell_display_layout();
-
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
             auto const persistent_surface_store = server.the_persistent_surface_store();
-#else
-            std::shared_ptr<mir::shell::PersistentSurfaceStore> const persistent_surface_store;
-#endif
+
             for (auto const& option : policies)
             {
                 if (selection == option.name)

=== modified file 'miral/window_management_trace.cpp'
--- miral/window_management_trace.cpp	2017-03-03 10:06:02 +0000
+++ miral/window_management_trace.cpp	2017-06-20 16:14:05 +0000
@@ -547,6 +547,24 @@
 }
 MIRAL_TRACE_EXCEPTION
 
+void miral::WindowManagementTrace::start_drag_and_drop(miral::WindowInfo& window_info, std::vector<uint8_t> const& handle)
+try {
+    log_input();
+    mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str());
+    trace_count++;
+    wrapped.start_drag_and_drop(window_info, handle);
+}
+MIRAL_TRACE_EXCEPTION
+
+void miral::WindowManagementTrace::end_drag_and_drop()
+try {
+    log_input();
+    mir::log_info("%s window_info=%s", __func__);
+    trace_count++;
+    wrapped.end_drag_and_drop();
+}
+MIRAL_TRACE_EXCEPTION
+
 void miral::WindowManagementTrace::modify_window(
     miral::WindowInfo& window_info, miral::WindowSpecification const& modifications)
 try {

=== modified file 'miral/window_management_trace.h'
--- miral/window_management_trace.h	2017-03-02 14:29:04 +0000
+++ miral/window_management_trace.h	2017-06-20 16:14:05 +0000
@@ -69,6 +69,8 @@
     virtual void focus_prev_within_application() override;
 
     virtual void raise_tree(Window const& root) override;
+    virtual void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) override;
+    virtual void end_drag_and_drop() override;
 
     virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override;
 

=== modified file 'miral/window_manager_tools.cpp'
--- miral/window_manager_tools.cpp	2017-03-02 14:29:04 +0000
+++ miral/window_manager_tools.cpp	2017-06-20 16:14:05 +0000
@@ -83,6 +83,12 @@
 void miral::WindowManagerTools::raise_tree(Window const& root)
 { tools->raise_tree(root); }
 
+void miral::WindowManagerTools::start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle)
+{ tools->start_drag_and_drop(window_info, handle); }
+
+void miral::WindowManagerTools::end_drag_and_drop()
+{ tools->end_drag_and_drop(); }
+
 void miral::WindowManagerTools::modify_window(WindowInfo& window_info, WindowSpecification const& modifications)
 { tools->modify_window(window_info,modifications); }
 

=== modified file 'miral/window_manager_tools_implementation.h'
--- miral/window_manager_tools_implementation.h	2017-03-02 14:29:04 +0000
+++ miral/window_manager_tools_implementation.h	2017-06-20 16:14:05 +0000
@@ -26,6 +26,7 @@
 
 #include <functional>
 #include <memory>
+#include <vector>
 
 namespace mir { namespace scene { class Surface; } }
 
@@ -66,6 +67,8 @@
     virtual auto window_at(mir::geometry::Point cursor) const -> Window = 0;
     virtual auto active_display() -> mir::geometry::Rectangle const = 0;
     virtual void raise_tree(Window const& root) = 0;
+    virtual void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) = 0;
+    virtual void end_drag_and_drop() = 0;
     virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0;
     virtual auto info_for_window_id(std::string const& id) const -> WindowInfo& = 0;
     virtual auto id_for_window(Window const& window) const -> std::string = 0;

=== modified file 'miral/window_specification.cpp'
--- miral/window_specification.cpp	2017-01-13 18:17:01 +0000
+++ miral/window_specification.cpp	2017-06-20 16:14:05 +0000
@@ -74,11 +74,9 @@
     state(spec.state),
     preferred_orientation(spec.preferred_orientation),
     aux_rect(spec.aux_rect),
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     placement_hints(spec.placement_hints),
     window_placement_gravity(spec.surface_placement_gravity),
     aux_rect_placement_gravity(spec.aux_rect_placement_gravity),
-#endif
     min_width(spec.min_width),
     min_height(spec.min_height),
     max_width(spec.max_width),
@@ -92,24 +90,10 @@
     input_shape(spec.input_shape),
     input_mode(),
     shell_chrome(spec.shell_chrome)
-#if MIRAL_MIR_DEFINES_POINTER_CONFINEMENT
     ,confine_pointer(spec.confine_pointer)
-#endif
 {
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     if (spec.aux_rect_placement_offset_x.is_set() && spec.aux_rect_placement_offset_y.is_set())
         aux_rect_placement_offset = Displacement{spec.aux_rect_placement_offset_x.value(), spec.aux_rect_placement_offset_y.value()};
-#endif
-
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 25, 0)
-    // mir_connection_create_spec_for_tooltip() didn't set an edge_attachment preference
-    if (aux_rect.is_set() && !spec.edge_attachment.is_set())
-    {
-        window_placement_gravity = mir_placement_gravity_northwest;
-        aux_rect_placement_gravity = mir_placement_gravity_northeast;
-        placement_hints = mir_placement_hints_flip_any;
-    }
-#endif
 
     if (spec.edge_attachment.is_set() && !placement_hints.is_set())
     {
@@ -166,12 +150,6 @@
 }
 
 template<typename Source>
-void copy_if_set(mir::optional_value<mir::graphics::BufferUsage>& dest, mir::optional_value<Source> const& source)
-{
-    if (source.is_set()) dest = static_cast<mir::graphics::BufferUsage>(source.value());
-}
-
-template<typename Source>
 void copy_if_set(mir::graphics::BufferUsage& dest, mir::optional_value<Source> const& source)
 {
     if (source.is_set()) dest = static_cast<mir::graphics::BufferUsage>(source.value());
@@ -179,14 +157,6 @@
 
 template<typename Source>
 void copy_if_set(
-    mir::optional_value<mir::graphics::DisplayConfigurationOutputId>& dest,
-    mir::optional_value<Source> const& source)
-{
-    if (source.is_set()) dest = static_cast<mir::graphics::DisplayConfigurationOutputId>(source.value());
-}
-
-template<typename Source>
-void copy_if_set(
     mir::graphics::DisplayConfigurationOutputId& dest,
     mir::optional_value<Source> const& source)
 {
@@ -229,11 +199,9 @@
     state(params.state),
     preferred_orientation(params.preferred_orientation),
     aux_rect(params.aux_rect),
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     placement_hints(params.placement_hints),
     window_placement_gravity(params.surface_placement_gravity),
     aux_rect_placement_gravity(params.aux_rect_placement_gravity),
-#endif
     min_width(params.min_width),
     min_height(params.min_height),
     max_width(params.max_width),
@@ -242,33 +210,15 @@
     height_inc(params.height_inc),
     min_aspect(),
     max_aspect(),
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 22, 0)
     streams(params.streams),
-#else
-    streams(),
-#endif
     parent(params.parent),
     input_shape(params.input_shape),
     input_mode(static_cast<InputReceptionMode>(params.input_mode)),
     shell_chrome(params.shell_chrome)
-#if MIRAL_MIR_DEFINES_POINTER_CONFINEMENT
     ,confine_pointer(params.confine_pointer)
-#endif
 {
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     if (params.aux_rect_placement_offset_x.is_set() && params.aux_rect_placement_offset_y.is_set())
         aux_rect_placement_offset = Displacement{params.aux_rect_placement_offset_x.value(), params.aux_rect_placement_offset_y.value()};
-#endif
-
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 25, 0)
-    // mir_connection_create_spec_for_tooltip() didn't set an edge_attachment preference
-    if (aux_rect.is_set() && !params.edge_attachment.is_set())
-    {
-        window_placement_gravity = mir_placement_gravity_northwest;
-        aux_rect_placement_gravity = mir_placement_gravity_northeast;
-        placement_hints = mir_placement_hints_flip_any;
-    }
-#endif
 
     if (params.edge_attachment.is_set() && !placement_hints.is_set())
     {
@@ -325,18 +275,12 @@
     copy_if_set(params.height_inc, height_inc);
     copy_if_set(params.min_aspect, min_aspect);
     copy_if_set(params.max_aspect, max_aspect);
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 22, 0)
     copy_if_set(params.streams, streams);
-#endif
     copy_if_set(params.parent, parent);
     copy_if_set(params.input_shape, input_shape);
     copy_if_set(params.input_mode, input_mode);
     copy_if_set(params.shell_chrome, shell_chrome);
-#if MIRAL_MIR_DEFINES_POINTER_CONFINEMENT
     copy_if_set(params.confine_pointer, confine_pointer);
-#endif
-
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
     copy_if_set(params.placement_hints, placement_hints);
     copy_if_set(params.surface_placement_gravity, window_placement_gravity);
     copy_if_set(params.aux_rect_placement_gravity, aux_rect_placement_gravity);
@@ -347,7 +291,6 @@
         params.aux_rect_placement_offset_x = offset.dx.as_int();
         params.aux_rect_placement_offset_y = offset.dy.as_int();
     }
-#endif
 }
 
 miral::WindowSpecification::WindowSpecification() :

=== modified file 'scripts/process_doxygen_xml.py'
--- scripts/process_doxygen_xml.py	2017-03-15 17:44:36 +0000
+++ scripts/process_doxygen_xml.py	2017-06-20 16:14:05 +0000
@@ -476,10 +476,21 @@
 
 MIRAL_1.3.1 {
 global:
+  extern "C++" {
+    miral::SetWindowManagementPolicy::?SetWindowManagementPolicy*;
+    miral::SetWindowManagementPolicy::SetWindowManagementPolicy*;
+    miral::SetWindowManagementPolicy::operator*;
+    typeinfo?for?miral::SetWindowManagementPolicy;
+    vtable?for?miral::SetWindowManagementPolicy;
+  };
+} MIRAL_1.3;
+
+MIRAL_1.4.0 {
+global:
   extern "C++" {'''
 
 END_NEW_STANZA = '''  };
-} MIRAL_1.3;'''
+} MIRAL_1.3.1;'''
 
 def _print_report():
     print OLD_STANZAS

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2017-02-13 16:23:29 +0000
+++ test/CMakeLists.txt	2017-06-20 16:14:05 +0000
@@ -39,6 +39,16 @@
         ${GTEST_INCLUDE_DIR}
 )
 
+# MIRAL_TEST_MODERN_FEATURES lists test sourcefiles that require a recent version of Mir
+if (MIRTEST_VERSION VERSION_LESS 0.27)
+    set(MIRAL_TEST_MODERN_FEATURES)
+else()
+    set(MIRAL_TEST_MODERN_FEATURES
+        drag_and_drop.cpp
+        client_mediated_gestures.cpp
+    )
+endif()
+
 add_executable(miral-test
     mru_window_list.cpp
     active_outputs.cpp
@@ -56,7 +66,9 @@
     display_reconfiguration.cpp
     active_window.cpp
     raise_tree.cpp
-    workspaces.cpp)
+    workspaces.cpp
+    ${MIRAL_TEST_MODERN_FEATURES}
+)
 
 target_link_libraries(miral-test
     ${MIRTEST_LDFLAGS}

=== modified file 'test/active_window.cpp'
--- test/active_window.cpp	2017-03-16 16:57:38 +0000
+++ test/active_window.cpp	2017-06-20 16:14:05 +0000
@@ -18,10 +18,10 @@
 
 #include "test_server.h"
 
+#include <mir/client/surface.h>
 #include <mir/client/window.h>
 #include <mir/client/window_spec.h>
 #include <mir_toolkit/mir_buffer_stream.h>
-#include <mir_toolkit/version.h>
 
 #include <miral/application_info.h>
 
@@ -35,11 +35,6 @@
 using namespace std::chrono_literals;
 using miral::WindowManagerTools;
 
-#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
-auto const mir_event_type_window = mir_event_type_surface;
-auto const mir_window_event_get_attribute = mir_surface_event_get_attribute;
-auto const mir_event_get_window_event = mir_event_get_surface_event;
-#endif
 
 namespace
 {
@@ -68,58 +63,79 @@
     mir::test::Signal signal;
 };
 
+struct TestWindow : Surface, Window
+{
+    using Surface::operator=;
+    using Window::operator=;
+};
+
 struct ActiveWindow : public miral::TestServer
 {
     FocusChangeSync sync1;
     FocusChangeSync sync2;
 
-    auto create_surface(Connection const& connection, char const* name, FocusChangeSync& sync) -> Window
-    {
-        auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
-            .set_buffer_usage(mir_buffer_usage_software)
+    void paint(Surface const& surface)
+    {
+        mir_buffer_stream_swap_buffers_sync(
+            mir_render_surface_get_buffer_stream(surface, 50, 50, mir_pixel_format_argb_8888));
+    }
+
+    auto create_window(Connection const& connection, char const* name, FocusChangeSync& sync) -> TestWindow
+    {
+        TestWindow result;
+
+        result = Surface{mir_connection_create_render_surface_sync(connection, 50, 50)};
+
+        auto const spec = WindowSpec::for_normal_window(connection, 50, 50)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
+            .add_surface(result, 50, 50, 0, 0)
             .set_name(name);
 
-        Window const surface{spec.create_window()};
-
-        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+        result = Window{spec.create_window()};
+
+        sync.exec([&]{ paint(result); });
+
         EXPECT_TRUE(sync.signal_raised());
 
-        return surface;
+        return result;
     }
 
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
-    auto create_tip(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> Window
+    auto create_tip(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> TestWindow
     {
+        TestWindow result;
+        result = Surface{mir_connection_create_render_surface_sync(connection, 50, 50)};
+
         MirRectangle aux_rect{10, 10, 10, 10};
-        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)
+        auto const spec = WindowSpec::for_tip(connection, 50, 50, parent, &aux_rect, mir_edge_attachment_any)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
+            .add_surface(result, 50, 50, 0, 0)
             .set_name(name);
 
-        Window const surface{spec.create_window()};
+        result = Window{spec.create_window()};
 
         // Expect this to timeout: A tip should not receive focus
-        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+        sync.exec([&]{ paint(result); });
         EXPECT_FALSE(sync.signal_raised());
 
-        return surface;
+        return result;
     }
-#endif
 
-    auto create_dialog(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> Window
+    auto create_dialog(Connection const& connection, char const* name, Window const& parent, FocusChangeSync& sync) -> TestWindow
     {
-        auto const spec = WindowSpec::for_dialog(connection, 50, 50, mir_pixel_format_argb_8888, parent)
-            .set_buffer_usage(mir_buffer_usage_software)
+        TestWindow result;
+        result = Surface{mir_connection_create_render_surface_sync(connection, 50, 50)};
+
+        auto const spec = WindowSpec::for_dialog(connection, 50, 50, parent)
             .set_event_handler(&FocusChangeSync::raise_signal_on_focus_change, &sync)
+            .add_surface(result, 50, 50, 0, 0)
             .set_name(name);
 
-        Window const surface{spec.create_window()};
+        result = Window{spec.create_window()};
 
-        sync.exec([&]{ mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(surface)); });
+        sync.exec([&]{ paint(result); });
         EXPECT_TRUE(sync.signal_raised());
 
-        return surface;
+        return result;
     }
 
     void assert_no_active_window()
@@ -151,7 +167,7 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const surface = create_surface(connection, test_name, sync1);
+    auto const window = create_window(connection, test_name, sync1);
 
     assert_active_window_is(test_name);
 }
@@ -160,9 +176,9 @@
 {
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
-    auto const surface = create_surface(connection, test_name, sync1);
+    auto const window = create_window(connection, test_name, sync1);
 
-    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+    sync1.exec([&]{ mir_window_set_state(window, mir_window_state_hidden); });
 
     EXPECT_TRUE(sync1.signal_raised());
     assert_no_active_window();
@@ -172,11 +188,11 @@
 {
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
-    auto const surface = create_surface(connection, test_name, sync1);
-
-    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
-
-    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_restored); });
+    auto const window = create_window(connection, test_name, sync1);
+
+    sync1.exec([&]{ mir_window_set_state(window, mir_window_state_hidden); });
+
+    sync1.exec([&]{ mir_window_set_state(window, mir_window_state_restored); });
 
     EXPECT_TRUE(sync1.signal_raised());
 
@@ -188,8 +204,8 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const first_surface = create_surface(connection, "first", sync1);
-    auto const surface = create_surface(connection, test_name, sync2);
+    auto const first_window = create_window(connection, "first", sync1);
+    auto const window = create_window(connection, test_name, sync2);
 
     assert_active_window_is(test_name);
 }
@@ -199,10 +215,10 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const first_surface = create_surface(connection, test_name, sync1);
-    auto const surface = create_surface(connection, another_name, sync2);
+    auto const first_window = create_window(connection, test_name, sync1);
+    auto const window = create_window(connection, another_name, sync2);
 
-    sync2.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+    sync2.exec([&]{ mir_window_set_state(window, mir_window_state_hidden); });
 
     EXPECT_TRUE(sync2.signal_raised());
     assert_active_window_is(test_name);
@@ -213,13 +229,13 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const first_surface = create_surface(connection, test_name, sync1);
-    auto const surface = create_surface(connection, another_name, sync2);
+    auto const first_window = create_window(connection, test_name, sync1);
+    auto const window = create_window(connection, another_name, sync2);
 
-    sync1.exec([&]{ mir_window_set_state(surface, mir_window_state_hidden); });
+    sync1.exec([&]{ mir_window_set_state(window, mir_window_state_hidden); });
 
     // Expect this to timeout
-    sync2.exec([&]{ mir_window_set_state(surface, mir_window_state_restored); });
+    sync2.exec([&]{ mir_window_set_state(window, mir_window_state_restored); });
 
     EXPECT_THAT(sync2.signal_raised(), Eq(false));
     assert_active_window_is(test_name);
@@ -230,8 +246,8 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const first_surface = create_surface(connection, test_name, sync1);
-    auto const surface = create_surface(connection, another_name, sync2);
+    auto const first_window = create_window(connection, test_name, sync1);
+    auto const window = create_window(connection, another_name, sync2);
 
     sync1.exec([&]{ invoke_tools([](WindowManagerTools& tools){ tools.focus_next_within_application(); }); });
 
@@ -245,8 +261,8 @@
     auto const connection = connect_client(test_name);
     auto const second_connection = connect_client(another_name);
 
-    auto const first_surface = create_surface(connection, test_name, sync1);
-    auto const surface = create_surface(second_connection, another_name, sync2);
+    auto const first_window = create_window(connection, test_name, sync1);
+    auto const window = create_window(second_connection, another_name, sync2);
 
     sync1.exec([&]{ invoke_tools([](WindowManagerTools& tools){ tools.focus_next_application(); }); });
 
@@ -259,12 +275,12 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const first_surface = create_surface(connection, test_name, sync1);
+    auto const first_window = create_window(connection, test_name, sync1);
 
     sync1.exec([&]
         {
             auto const second_connection = connect_client(another_name);
-            auto const surface = create_surface(second_connection, another_name, sync2);
+            auto const window = create_window(second_connection, another_name, sync2);
             assert_active_window_is(another_name);
         });
 
@@ -272,20 +288,19 @@
     assert_active_window_is(test_name);
 }
 
-#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
 TEST_F(ActiveWindow, selecting_a_tip_makes_parent_active)
 {
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const parent = create_surface(connection, test_name, sync1);
+    auto const parent = create_window(connection, test_name, sync1);
 
     miral::Window parent_window;
     invoke_tools([&](WindowManagerTools& tools){ parent_window = tools.active_window(); });
 
     // Steal the focus
     auto second_connection = connect_client(another_name);
-    auto second_surface = create_surface(second_connection, another_name, sync2);
+    auto second_surface = create_window(second_connection, another_name, sync2);
 
     auto const tip = create_tip(connection, "tip", parent, sync2);
 
@@ -298,7 +313,6 @@
 
     assert_active_window_is(test_name);
 }
-#endif
 
 TEST_F(ActiveWindow, selecting_a_parent_makes_dialog_active)
 {
@@ -306,7 +320,7 @@
     auto const dialog_name = "dialog";
     auto const connection = connect_client(test_name);
 
-    auto const parent = create_surface(connection, test_name, sync1);
+    auto const parent = create_window(connection, test_name, sync1);
 
     miral::Window parent_window;
     invoke_tools([&](WindowManagerTools& tools){ parent_window = tools.active_window(); });
@@ -315,7 +329,7 @@
 
     // Steal the focus
     auto second_connection = connect_client(another_name);
-    auto second_surface = create_surface(second_connection, another_name, sync1);
+    auto second_surface = create_window(second_connection, another_name, sync1);
 
     sync2.exec([&]{ invoke_tools([&](WindowManagerTools& tools){ tools.select_active_window(parent_window); }); });
 
@@ -328,7 +342,7 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const parent = create_surface(connection, test_name, sync1);
+    auto const parent = create_window(connection, test_name, sync1);
     auto const input_method = WindowSpec::for_input_method(connection, 50, 50, parent).create_window();
 
     assert_active_window_is(test_name);
@@ -347,7 +361,7 @@
     char const* const test_name = __PRETTY_FUNCTION__;
     auto const connection = connect_client(test_name);
 
-    auto const parent = create_surface(connection, test_name, sync1);
+    auto const parent = create_window(connection, test_name, sync1);
     auto const satellite = WindowSpec::for_satellite(connection, 50, 50, parent).create_window();
 
     assert_active_window_is(test_name);
@@ -368,7 +382,7 @@
     auto const dialog_name = "dialog";
     auto const connection = connect_client(parent_name);
 
-    auto const parent = create_surface(connection, parent_name, sync1);
+    auto const parent = create_window(connection, parent_name, sync1);
     auto const dialog = create_dialog(connection, dialog_name, parent, sync2);
 
     sync1.exec([&]{ mir_window_set_state(dialog, mir_window_state_hidden); });
@@ -386,8 +400,8 @@
     auto const another_window_name = "another window";
     auto const connection = connect_client(parent_name);
 
-    auto const parent = create_surface(connection, parent_name, sync1);
-    auto const another_window = create_surface(connection, another_window_name, sync2);
+    auto const parent = create_window(connection, parent_name, sync1);
+    auto const another_window = create_window(connection, another_window_name, sync2);
     auto const dialog = create_dialog(connection, dialog_name, parent, sync3);
 
     sync1.exec([&]{ mir_window_set_state(dialog, mir_window_state_hidden); });

=== added file 'test/client_mediated_gestures.cpp'
--- test/client_mediated_gestures.cpp	1970-01-01 00:00:00 +0000
+++ test/client_mediated_gestures.cpp	2017-06-20 16:14:05 +0000
@@ -0,0 +1,295 @@
+/*
+ * 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 <mir/client/surface.h>
+#include <mir/client/window_spec.h>
+
+#include <mir_toolkit/mir_window.h>
+#include <mir_toolkit/mir_blob.h>
+
+#include <mir/geometry/displacement.h>
+#include <mir/input/input_device_info.h>
+#include <mir/input/device_capability.h>
+#include <mir/shell/canonical_window_manager.h>
+#include <mir/shell/shell.h>
+
+#include <mir_test_framework/connected_client_with_a_window.h>
+#include <mir_test_framework/fake_input_device.h>
+#include <mir_test_framework/stub_server_platform_factory.h>
+#include <mir/test/event_factory.h>
+#include <mir/test/fake_shared.h>
+#include <mir/test/signal.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <linux/input.h>
+
+#include <atomic>
+
+using namespace std::chrono_literals;
+using namespace mir::geometry;
+using namespace testing;
+using mir::test::fake_shared;
+using mir::test::Signal;
+
+namespace
+{
+class Cookie
+{
+public:
+    Cookie() = default;
+
+    explicit Cookie(MirCookie const* cookie) : self{cookie, deleter} {}
+
+    operator MirCookie const*() const { return self.get(); }
+
+    auto get() const -> MirCookie const* { return self.get(); }
+
+    void reset() { self.reset(); }
+
+    void reset(MirCookie const* cookie) { self.reset(cookie, deleter); }
+
+private:
+    static void deleter(MirCookie const* cookie) { mir_cookie_release(cookie); }
+
+    std::shared_ptr<MirCookie const> self;
+};
+
+void mir_cookie_release(Cookie const&) = delete;
+
+struct MockWindowManager : mir::shell::CanonicalWindowManager
+{
+    using mir::shell::CanonicalWindowManager::CanonicalWindowManager;
+
+    MOCK_METHOD3(handle_request_move,
+        void(std::shared_ptr<mir::scene::Session> const&, std::shared_ptr<mir::scene::Surface> const&, uint64_t));
+};
+
+struct MouseMoverAndFaker
+{
+    void start_dragging_mouse()
+    {
+        using namespace mir::input::synthesis;
+        fake_mouse->emit_event(a_button_down_event().of_button(BTN_LEFT));
+    }
+
+    void move_mouse(Displacement const& displacement)
+    {
+        using mir::input::synthesis::a_pointer_event;
+        fake_mouse->emit_event(a_pointer_event().with_movement(displacement.dx.as_int(), displacement.dy.as_int()));
+    }
+
+    void release_mouse()
+    {
+        using namespace mir::input::synthesis;
+        fake_mouse->emit_event(a_button_up_event().of_button(BTN_LEFT));
+    }
+
+private:
+    std::unique_ptr<mir_test_framework::FakeInputDevice> fake_mouse{
+        mir_test_framework::add_fake_input_device(
+            mir::input::InputDeviceInfo{"mouse", "mouse-uid", mir::input::DeviceCapability::pointer})
+    };
+};
+
+Rectangle const screen_geometry{{0,   0}, {800, 600}};
+auto const receive_event_timeout = 90s;
+
+struct ClientMediatedUserGestures : mir_test_framework::ConnectedClientWithAWindow,
+                                    MouseMoverAndFaker
+{
+    void SetUp() override
+    {
+        initial_display_layout({screen_geometry});
+        server.override_the_window_manager_builder([this](mir::shell::FocusController* focus_controller)
+            {
+                return window_manager =
+                    std::make_shared<MockWindowManager>(focus_controller, server.the_shell_display_layout());
+            });
+
+        mir_test_framework::ConnectedClientWithAWindow::SetUp();
+        mir_window_set_event_handler(window, &window_event_handler, this);
+
+        paint_window();
+
+        center_mouse();
+    }
+
+    void TearDown() override
+    {
+        reset_window_event_handler();
+        window_manager.reset();
+        surface.reset();
+        mir_test_framework::ConnectedClientWithAWindow::TearDown();
+    }
+
+    auto user_initiates_gesture() -> Cookie;
+
+    std::shared_ptr<MockWindowManager> window_manager;
+
+private:
+    void center_mouse();
+    void paint_window();
+    void set_window_event_handler(std::function<void(MirEvent const* event)> const& handler);
+    void reset_window_event_handler();
+    void invoke_window_event_handler(MirEvent const* event)
+    {
+        std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+        window_event_handler_(event);
+    }
+
+    mir::client::Surface surface;
+
+    std::mutex window_event_handler_mutex;
+    std::function<void(MirEvent const* event)> window_event_handler_ = [](MirEvent const*) {};
+
+    static void window_event_handler(MirWindow* window, MirEvent const* event, void* context);
+};
+
+void ClientMediatedUserGestures::set_window_event_handler(std::function<void(MirEvent const* event)> const& handler)
+{
+    std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+    window_event_handler_ = handler;
+}
+
+void ClientMediatedUserGestures::reset_window_event_handler()
+{
+    std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+    window_event_handler_ = [](MirEvent const*) {};
+}
+
+void ClientMediatedUserGestures::window_event_handler(MirWindow* /*window*/, MirEvent const* event, void* context)
+{
+    static_cast<ClientMediatedUserGestures*>(context)->invoke_window_event_handler(event);
+}
+
+void ClientMediatedUserGestures::paint_window()
+{
+    {
+        surface = mir::client::Surface{mir_connection_create_render_surface_sync(connection, 42, 42)};
+        auto const spec = mir::client::WindowSpec::for_changes(connection);
+        mir_window_spec_add_render_surface(spec, surface, 42, 42, 0, 0);
+        mir_window_apply_spec(window, spec);
+    }
+
+    Signal have_focus;
+
+    set_window_event_handler([&](MirEvent const* event)
+        {
+            if (mir_event_get_type(event) != mir_event_type_window)
+                return;
+
+            auto const window_event = mir_event_get_window_event(event);
+            if (mir_window_event_get_attribute(window_event) != mir_window_attrib_focus)
+                return;
+
+            if (mir_window_event_get_attribute_value(window_event))
+                have_focus.raise();
+        });
+
+    mir_buffer_stream_swap_buffers_sync(mir_render_surface_get_buffer_stream(surface, 42, 42, mir_pixel_format_argb_8888));
+
+    EXPECT_THAT(have_focus.wait_for(receive_event_timeout), Eq(true));
+
+    reset_window_event_handler();
+}
+
+void ClientMediatedUserGestures::center_mouse()
+{
+    Signal have_mouseover;
+
+    set_window_event_handler([&](MirEvent const* event)
+        {
+            if (mir_event_get_type(event) != mir_event_type_input)
+                return;
+
+            auto const input_event = mir_event_get_input_event(event);
+
+            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+                return;
+
+            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter)
+                return;
+
+            have_mouseover.raise();
+        });
+
+    move_mouse(0.5 * as_displacement(screen_geometry.size));
+
+// We miss the "mouseover" occasionally (with valgrind and heavy stress about 1/20).
+// But it isn't essential for the test and we've probably waited long enough
+// for the mouse-down needed by the test to reach the window.
+//    EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout), Eq(true));
+    have_mouseover.wait_for(receive_event_timeout);
+
+    reset_window_event_handler();
+}
+
+auto ClientMediatedUserGestures::user_initiates_gesture() -> Cookie
+{
+    Cookie cookie;
+    Signal have_cookie;
+
+    set_window_event_handler([&](MirEvent const* event)
+        {
+            if (mir_event_get_type(event) != mir_event_type_input)
+                return;
+
+            auto const input_event = mir_event_get_input_event(event);
+
+            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+                return;
+
+            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_down)
+                return;
+
+            cookie = Cookie{mir_input_event_get_cookie(input_event)};
+            have_cookie.raise();
+        });
+
+    start_dragging_mouse();
+
+    EXPECT_THAT(have_cookie.wait_for(receive_event_timeout), Eq(true));
+
+    reset_window_event_handler();
+    return cookie;
+}
+}
+
+TEST_F(ClientMediatedUserGestures, when_user_initiates_gesture_client_receives_cookie)
+{
+    auto const cookie = user_initiates_gesture();
+
+    EXPECT_THAT(cookie.get(), NotNull());
+}
+
+TEST_F(ClientMediatedUserGestures, when_client_initiates_move_window_manager_handles_request)
+{
+    auto const cookie = user_initiates_gesture();
+    Signal have_request;
+    EXPECT_CALL(*window_manager, handle_request_move(_, _, _)).WillOnce(InvokeWithoutArgs([&]{ have_request.raise(); }));
+
+    mir_window_request_user_move(window, cookie);
+
+    EXPECT_THAT(have_request.wait_for(receive_event_timeout), Eq(true));
+}

=== added file 'test/drag_and_drop.cpp'
--- test/drag_and_drop.cpp	1970-01-01 00:00:00 +0000
+++ test/drag_and_drop.cpp	2017-06-20 16:14:05 +0000
@@ -0,0 +1,653 @@
+/*
+ * 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 <miral/window_management_policy_addendum2.h>
+
+#include <mir/client/blob.h>
+#include <mir/client/cookie.h>
+#include <mir/client/surface.h>
+#include <mir/client/window.h>
+#include <mir/client/window_spec.h>
+#include <mir_toolkit/mir_buffer_stream.h>
+#include <mir_toolkit/extensions/drag_and_drop.h>
+
+#include <mir/geometry/displacement.h>
+#include <mir/input/input_device_info.h>
+#include <mir/input/device_capability.h>
+#include <mir/shell/shell.h>
+
+#include "test_server.h"
+#include <mir_test_framework/fake_input_device.h>
+#include <mir_test_framework/stub_server_platform_factory.h>
+#include <mir/test/event_factory.h>
+#include <mir/test/signal.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <linux/input.h>
+#include <uuid/uuid.h>
+
+#include <boost/throw_exception.hpp>
+#include <atomic>
+
+using namespace std::chrono_literals;
+using namespace mir::client;
+using namespace mir::geometry;
+using namespace testing;
+using mir::test::Signal;
+
+namespace
+{
+struct MouseMoverAndFaker
+{
+    void start_dragging_mouse()
+    {
+        using namespace mir::input::synthesis;
+        fake_mouse->emit_event(a_button_down_event().of_button(BTN_LEFT));
+    }
+
+    void move_mouse(Displacement const& displacement)
+    {
+        using mir::input::synthesis::a_pointer_event;
+        fake_mouse->emit_event(a_pointer_event().with_movement(displacement.dx.as_int(), displacement.dy.as_int()));
+    }
+
+    void release_mouse()
+    {
+        using namespace mir::input::synthesis;
+        fake_mouse->emit_event(a_button_up_event().of_button(BTN_LEFT));
+    }
+
+private:
+    std::unique_ptr<mir_test_framework::FakeInputDevice> fake_mouse{
+        mir_test_framework::add_fake_input_device(
+            mir::input::InputDeviceInfo{"mouse", "mouse-uid", mir::input::DeviceCapability::pointer})};
+};
+
+Rectangle const screen_geometry{{0,0}, {800,600}};
+auto const receive_event_timeout = 1s; //90s;
+
+struct ConnectedClientWithAWindow : miral::TestServer
+{
+    Connection connection;
+    Surface surface;
+    Window window;
+
+    void SetUp() override
+    {
+        miral::TestServer::SetUp();
+        connection = connect_client(__func__);
+        auto const width = surface_size.width.as_int();
+        auto const height = surface_size.height.as_int();
+        surface = Surface{mir_connection_create_render_surface_sync(connection, width, height)};
+        window = WindowSpec::for_normal_window(connection, width, height)
+            .set_name("ConnectedClientWithAWindow")
+            .add_surface(surface, width, height, 0, 0)
+            .create_window();
+    }
+
+    void TearDown() override
+    {
+        window.reset();
+        surface.reset();
+        connection.reset();
+        miral::TestServer::TearDown();
+    }
+
+    mir::geometry::Size const surface_size {640, 480};
+};
+
+struct DragAndDrop : ConnectedClientWithAWindow,
+                     MouseMoverAndFaker
+{
+    MirDragAndDropV1 const* dnd = nullptr;
+
+    void SetUp() override
+    {
+        mir_test_framework::set_next_display_rects(std::unique_ptr<std::vector<Rectangle>>(new std::vector<Rectangle>({screen_geometry})));
+
+        ConnectedClientWithAWindow::SetUp();
+        dnd = mir_drag_and_drop_v1(connection);
+        mir_window_set_event_handler(window, &window_event_handler, this);
+        if (dnd) dnd->set_start_drag_and_drop_callback(window, &window_dnd_start_handler, this);
+
+        create_target_window();
+
+        paint_window(surface, window);
+
+        center_mouse();
+    }
+
+    void TearDown() override
+    {
+        reset_window_event_handler(target_window);
+        reset_window_event_handler(window);
+        target_window.reset();
+        target_surface.reset();
+        another_connection.reset();
+        ConnectedClientWithAWindow::TearDown();
+    }
+
+    auto user_initiates_drag() -> Cookie;
+    auto client_requests_drag(Cookie const& cookie) -> Blob;
+    auto handle_from_mouse_move() -> Blob;
+    auto handle_from_mouse_leave() -> Blob;
+    auto handle_from_mouse_enter() -> Blob;
+    auto handle_from_mouse_release() -> Blob;
+    auto count_of_handles_when_moving_mouse() -> int;
+
+private:
+    auto build_window_manager_policy(miral::WindowManagerTools const& tools) -> std::unique_ptr<TestWindowManagerPolicy> override;
+    void center_mouse();
+    void paint_window(MirRenderSurface* s, MirWindow* w);
+    void set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler);
+    void set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler);
+    void reset_window_event_handler(MirWindow* window);
+
+    void create_target_window()
+    {
+        another_connection = connect_client("another_connection");
+        auto const height = screen_geometry.size.height.as_int();
+        auto const width = screen_geometry.size.width.as_int();
+        target_surface = Surface{mir_connection_create_render_surface_sync(another_connection, width,height)};
+        target_window = WindowSpec::for_normal_window(another_connection, width, height)
+            .set_name("target_window")
+            .add_surface(target_surface, width, height, 0, 0)
+            .set_event_handler(&window_event_handler, this)
+            .create_window();
+
+        paint_window(target_surface, target_window);
+    }
+
+    void invoke_window_event_handler(MirWindow* window, MirEvent const* event)
+    {
+        std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+        if (window == this->window) window_event_handler_(event);
+        if (window == target_window) target_window_event_handler_(event);
+    }
+
+    void invoke_window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event)
+    {
+        std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+        if (window == this->window) window_dnd_start_(event);
+    }
+
+    std::mutex window_event_handler_mutex;
+    std::function<void(MirDragAndDropEvent const* event)> window_dnd_start_ = [](MirDragAndDropEvent const*) {};
+    std::function<void(MirEvent const* event)> window_event_handler_ = [](MirEvent const*) {};
+    std::function<void(MirEvent const* event)> target_window_event_handler_ = [](MirEvent const*) {};
+
+    static void window_event_handler(MirWindow* window, MirEvent const* event, void* context);
+    static void window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context);
+
+    Connection another_connection;
+    Surface    target_surface;
+    Window     target_window;
+};
+
+void DragAndDrop::set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler)
+{
+    std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+    if (window == this->window) window_event_handler_ = handler;
+    if (window == target_window) target_window_event_handler_ = handler;
+}
+
+void DragAndDrop::set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler)
+{
+std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
+if (window == this->window) window_dnd_start_ = handler;
+}
+
+
+void DragAndDrop::reset_window_event_handler(MirWindow* window)
+{
+    if (window == this->window) window_event_handler_ = [](MirEvent const*) {};
+    if (window == target_window) target_window_event_handler_ = [](MirEvent const*) {};
+}
+
+void DragAndDrop::paint_window(MirRenderSurface* s, MirWindow* w)
+{
+    Signal have_focus;
+
+    set_window_event_handler(w, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_window)
+            return;
+
+        auto const window_event = mir_event_get_window_event(event);
+        if (mir_window_event_get_attribute(window_event) != mir_window_attrib_focus)
+            return;
+
+        if (mir_window_event_get_attribute_value(window_event))
+            have_focus.raise();
+        });
+
+    int width;
+    int height;
+    mir_render_surface_get_size(s, &width, &height);
+    mir_buffer_stream_swap_buffers_sync(
+        mir_render_surface_get_buffer_stream(s, width, height, mir_pixel_format_argb_8888));
+
+    EXPECT_THAT(have_focus.wait_for(receive_event_timeout), Eq(true));
+
+    reset_window_event_handler(w);
+}
+
+void DragAndDrop::center_mouse()
+{
+    Signal have_mouseover;
+
+    set_window_event_handler(window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter)
+            return;
+
+        have_mouseover.raise();
+        });
+
+    move_mouse(0.5 * as_displacement(screen_geometry.size));
+
+// We miss the "mouseover" occasionally (with valgrind and heavy stress about 1/20).
+// But it isn't essential for the test and we've probably waited long enough
+// for the mouse-down needed by the test to reach the window.
+//    EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout), Eq(true));
+    have_mouseover.wait_for(receive_event_timeout);
+
+    reset_window_event_handler(window);
+}
+
+void DragAndDrop::window_event_handler(MirWindow* window, MirEvent const* event, void* context)
+{
+    static_cast<DragAndDrop*>(context)->invoke_window_event_handler(window, event);
+}
+
+void DragAndDrop::window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context)
+{
+    static_cast<DragAndDrop*>(context)->invoke_window_dnd_start_handler(window, event);
+}
+
+
+auto DragAndDrop::user_initiates_drag() -> Cookie
+{
+    Cookie cookie;
+    Signal have_cookie;
+
+    set_window_event_handler(window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_down)
+            return;
+
+        cookie = Cookie{mir_input_event_get_cookie(input_event)};
+        have_cookie.raise();
+        });
+
+    start_dragging_mouse();
+
+    EXPECT_THAT(have_cookie.wait_for(receive_event_timeout), Eq(true));
+
+    reset_window_event_handler(window);
+    return cookie;
+}
+
+auto DragAndDrop::client_requests_drag(Cookie const& cookie) -> Blob
+{
+    Blob blob;
+    Signal initiated;
+
+    set_window_dnd_start_handler(window, [&](MirDragAndDropEvent const* event)
+        {
+        if (dnd)
+            blob.reset(dnd->start_drag_and_drop(event));
+
+        if (blob)
+            initiated.raise();
+        });
+
+    EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+    if (dnd)
+        dnd->request_drag_and_drop(window, cookie);
+
+    EXPECT_TRUE(initiated.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(window);
+    return blob;
+}
+
+auto DragAndDrop::handle_from_mouse_move() -> Blob
+{
+    Blob blob;
+    Signal have_blob;
+
+    set_window_event_handler(window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+        if (dnd)
+            blob.reset(dnd->pointer_drag_and_drop(pointer_event));
+
+        if (blob)
+            have_blob.raise();
+        });
+
+    move_mouse({1,1});
+
+    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(window);
+    return blob;
+}
+
+auto DragAndDrop::handle_from_mouse_leave() -> Blob
+{
+    Blob blob;
+    Signal have_blob;
+
+    set_window_event_handler(window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        if (mir_pointer_event_action(pointer_event) != mir_pointer_action_leave)
+            return;
+
+        EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+        if (dnd)
+            blob.reset(dnd->pointer_drag_and_drop(pointer_event));
+
+        if (blob)
+            have_blob.raise();
+        });
+
+    move_mouse({1,1});
+    move_mouse(0.5 * as_displacement(surface_size));
+
+    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(window);
+    return blob;
+}
+
+auto DragAndDrop::handle_from_mouse_enter() -> Blob
+{
+    Blob blob;
+    Signal have_blob;
+
+    set_window_event_handler(target_window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter)
+            return;
+
+        EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+        if (dnd)
+            blob.reset(dnd->pointer_drag_and_drop(pointer_event));
+
+        if (blob)
+            have_blob.raise();
+        });
+
+    move_mouse({1,1});
+    move_mouse(0.5 * as_displacement(surface_size));
+
+    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(target_window);
+    return blob;
+}
+
+auto DragAndDrop::handle_from_mouse_release() -> Blob
+{
+    Blob blob;
+    Signal have_blob;
+
+    set_window_event_handler(target_window, [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_up)
+            return;
+
+        EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+        if (dnd)
+            blob.reset(dnd->pointer_drag_and_drop(pointer_event));
+
+        if (blob)
+            have_blob.raise();
+        });
+
+    move_mouse({1,1});
+    move_mouse(0.5 * as_displacement(surface_size));
+    release_mouse();
+
+    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(target_window);
+    return blob;
+}
+
+auto DragAndDrop::count_of_handles_when_moving_mouse() -> int
+{
+    Signal have_3_events;
+    std::atomic<int> events{0};
+    std::atomic<int> handles{0};
+
+    auto counter = [&](MirEvent const* event)
+        {
+        if (mir_event_get_type(event) != mir_event_type_input)
+            return;
+
+        auto const input_event = mir_event_get_input_event(event);
+
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
+            return;
+
+        auto const pointer_event = mir_input_event_get_pointer_event(input_event);
+
+        EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
+
+        Blob blob;
+        if (dnd)
+            blob.reset(dnd->pointer_drag_and_drop(pointer_event));
+
+        if (blob)
+            handles.fetch_add(1);
+
+        if (events.fetch_add(1) == 2)
+            have_3_events.raise();
+        };
+
+    set_window_event_handler(window, counter);
+    set_window_event_handler(target_window, counter);
+
+    start_dragging_mouse();
+    move_mouse({1,1});
+    release_mouse();
+
+    EXPECT_TRUE(have_3_events.wait_for(receive_event_timeout));
+
+    reset_window_event_handler(window);
+    reset_window_event_handler(target_window);
+    return handles;
+}
+
+auto DragAndDrop::build_window_manager_policy(miral::WindowManagerTools const& tools) -> std::unique_ptr<TestWindowManagerPolicy>
+{
+    struct DnDWindowManagerPolicy : miral::TestServer::TestWindowManagerPolicy, miral::WindowManagementPolicyAddendum2
+    {
+        using miral::TestServer::TestWindowManagerPolicy::TestWindowManagerPolicy;
+
+        void handle_request_drag_and_drop(miral::WindowInfo& window_info) override
+        {
+            uuid_t uuid;
+            uuid_generate(uuid);
+            std::vector<uint8_t> const handle{std::begin(uuid), std::end(uuid)};
+
+            tools.start_drag_and_drop(window_info, handle);
+        }
+
+        void handle_request_move(miral::WindowInfo&, MirInputEvent const*) override {}
+    };
+
+    return std::make_unique<DnDWindowManagerPolicy>(tools, *this);
+}
+
+MATCHER_P(BlobContentEq, p, "")
+{
+    if (!arg || !p)
+        return false;
+    if (mir_blob_size(arg) != mir_blob_size(p))
+        return false;
+    return !memcmp(mir_blob_data(arg), mir_blob_data(p), mir_blob_size(p));
+}
+}
+
+TEST_F(DragAndDrop, when_user_initiates_drag_client_receives_cookie)
+{
+    auto const cookie = user_initiates_drag();
+
+    EXPECT_THAT(cookie, NotNull());
+}
+
+TEST_F(DragAndDrop, when_client_requests_drags_it_receives_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+
+    auto const handle = client_requests_drag(cookie);
+
+    EXPECT_THAT(handle, NotNull());
+}
+
+TEST_F(DragAndDrop, during_drag_when_user_moves_mouse_client_receives_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+    auto const handle_from_request = client_requests_drag(cookie);
+
+    auto const handle = handle_from_mouse_move();
+
+    EXPECT_THAT(handle, NotNull());
+    EXPECT_THAT(handle, BlobContentEq(handle_from_request));
+}
+
+TEST_F(DragAndDrop, when_drag_moves_from_window_leave_event_contains_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+    auto const handle_from_request = client_requests_drag(cookie);
+
+    auto const handle = handle_from_mouse_leave();
+
+    EXPECT_THAT(handle, NotNull());
+    EXPECT_THAT(handle, BlobContentEq(handle_from_request));
+}
+
+TEST_F(DragAndDrop, when_drag_enters_target_window_enter_event_contains_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+    auto const handle_from_request = client_requests_drag(cookie);
+
+    auto const handle = handle_from_mouse_enter();
+
+    EXPECT_THAT(handle, NotNull());
+    EXPECT_THAT(handle, BlobContentEq(handle_from_request));
+}
+
+TEST_F(DragAndDrop, when_drag_releases_target_window_release_event_contains_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+    auto const handle_from_request = client_requests_drag(cookie);
+
+    auto const handle = handle_from_mouse_release();
+
+    EXPECT_THAT(handle, NotNull());
+    EXPECT_THAT(handle, BlobContentEq(handle_from_request));
+}
+
+TEST_F(DragAndDrop, after_drag_finishes_pointer_events_no_longer_contain_handle)
+{
+    auto const cookie = user_initiates_drag();
+    ASSERT_THAT(cookie, NotNull());
+    client_requests_drag(cookie);
+    handle_from_mouse_release();
+
+    invoke_tools([](miral::WindowManagerTools& tools) { tools.end_drag_and_drop(); });
+
+    EXPECT_THAT(count_of_handles_when_moving_mouse(), Eq(0));
+}

=== modified file 'test/select_active_window.cpp'
--- test/select_active_window.cpp	2017-01-13 18:17:01 +0000
+++ test/select_active_window.cpp	2017-06-20 16:14:05 +0000
@@ -32,8 +32,6 @@
 Rectangle const display_area{{display_left,  display_top},
                              {display_width, display_height}};
 
-auto const null_window = Window{};
-
 struct SelectActiveWindow : TestWindowManagerTools
 {
 

=== modified file 'test/test_server.cpp'
--- test/test_server.cpp	2017-03-20 12:28:06 +0000
+++ test/test_server.cpp	2017-06-20 16:14:05 +0000
@@ -29,9 +29,7 @@
 #include <mir/server.h>
 #include <mir/version.h>
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
 #include <mir_test_framework/headless_display_buffer_compositor_factory.h>
-#endif
 
 #include <boost/throw_exception.hpp>
 
@@ -52,7 +50,6 @@
     CanonicalWindowManagerPolicy{tools}
 {
     test_fixture.tools = tools;
-    test_fixture.policy = this;
 }
 
 miral::TestServer::TestServer() :
@@ -71,10 +68,6 @@
 
 void miral::TestServer::SetUp()
 {
-#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 25, 0)
-    mtf::set_next_preset_display({}); // Workaround for lp:1611337
-#endif
-
     mir::test::AutoJoinThread t([this]
          {
             auto init = [this](mir::Server& server)
@@ -93,23 +86,17 @@
                                 });
                         });
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
                     server.override_the_display_buffer_compositor_factory([]
                         {
                             return std::make_shared<mtf::HeadlessDisplayBufferCompositorFactory>();
                         });
-#endif
 
                     server.override_the_window_manager_builder([this, &server](msh::FocusController* focus_controller)
                         -> std::shared_ptr<msh::WindowManager>
                         {
                             auto const display_layout = server.the_shell_display_layout();
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
                             auto const persistent_surface_store = server.the_persistent_surface_store();
-#else
-                            std::shared_ptr<mir::shell::PersistentSurfaceStore> const persistent_surface_store;
-#endif
 
                             auto builder = [this](WindowManagerTools const& tools) -> std::unique_ptr<miral::WindowManagementPolicy>
                                 {

=== modified file 'test/test_server.h'
--- test/test_server.h	2017-02-14 17:11:07 +0000
+++ test/test_server.h	2017-06-20 16:14:05 +0000
@@ -69,7 +69,6 @@
 
 private:
     WindowManagerTools tools{nullptr};
-    WindowManagementPolicy* policy{nullptr};
     std::weak_ptr<mir::shell::WindowManager> window_manager;
     mir::test::AutoJoinThread server_thread;
     std::mutex mutex;

=== modified file 'test/window_id.cpp'
--- test/window_id.cpp	2017-03-03 12:31:47 +0000
+++ test/window_id.cpp	2017-06-20 16:14:05 +0000
@@ -42,14 +42,13 @@
     }
 };
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 0)
 TEST_F(WindowId, server_can_identify_window_specified_by_client)
 {
     char const* const test_name = __PRETTY_FUNCTION__;
     using namespace mir::client;
 
     auto const connection = connect_client(test_name);
-    auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_window(connection, 50, 50)
         .set_name(test_name);
 
     Window const surface{spec.create_window()};
@@ -71,7 +70,7 @@
     using namespace mir::client;
 
     auto const connection = connect_client(test_name);
-    auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
+    auto const spec = WindowSpec::for_normal_window(connection, 50, 50)
         .set_name(test_name);
 
     Window const surface{spec.create_window()};
@@ -86,46 +85,6 @@
             ASSERT_THAT(client_surface_id.c_str(), Eq(id));
         });
 }
-#else
-TEST_F(WindowId, server_fails_gracefully_to_identify_window_specified_by_client)
-{
-    char const* const test_name = __PRETTY_FUNCTION__;
-    using namespace mir::client;
-
-    auto const connection = connect_client(test_name);
-    auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_name(test_name);
-
-    Window const surface{spec.create_window()};
-
-    mir::client::WindowId client_surface_id{surface};
-
-    invoke_tools([&](miral::WindowManagerTools& tools)
-        {
-            EXPECT_THROW(tools.info_for_window_id(client_surface_id.c_str()), std::runtime_error);
-        });
-}
-
-TEST_F(WindowId, server_fails_gracefully_to_return_id_for_window)
-{
-    char const* const test_name = __PRETTY_FUNCTION__;
-    using namespace mir::client;
-
-    auto const connection = connect_client(test_name);
-    auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_name(test_name);
-
-    Window const surface{spec.create_window()};
-
-    mir::client::WindowId client_surface_id{surface};
-
-    invoke_tools([&](miral::WindowManagerTools& tools)
-        {
-            auto window = get_first_window(tools);
-            EXPECT_THROW(tools.id_for_window(window), std::runtime_error);
-        });
-}
-#endif
 
 TEST_F(WindowId, server_fails_gracefully_to_identify_window_from_garbage_id)
 {
@@ -133,8 +92,7 @@
     using namespace mir::client;
 
     auto const connection = connect_client(test_name);
-    auto const spec = WindowSpec::for_normal_window(connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_name(test_name);
+    auto const spec = WindowSpec::for_normal_window(connection, 50, 50).set_name(test_name);
 
     Window const surface{spec.create_window()};
 

=== modified file 'test/window_placement_client_api.cpp'
--- test/window_placement_client_api.cpp	2017-02-14 11:49:59 +0000
+++ test/window_placement_client_api.cpp	2017-06-20 16:14:05 +0000
@@ -16,19 +16,8 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#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>
-auto const mir_event_get_window_placement_event = mir_event_get_surface_placement_event;
-#else
 #include <mir_toolkit/events/window_placement.h>
-#endif
-#endif
 
-#include <mir/client/detail/mir_forward_compatibility.h>
 #include <mir/client/window_spec.h>
 #include <mir/client/window.h>
 
@@ -57,7 +46,7 @@
         char const* const test_name = __PRETTY_FUNCTION__;
 
         connection = connect_client(test_name);
-        auto spec = WindowSpec::for_normal_window(connection, 400, 400, mir_pixel_format_argb_8888)
+        auto spec = WindowSpec::for_normal_window(connection, 400, 400)
             .set_name(test_name);
 
         parent = spec.create_window();
@@ -78,12 +67,6 @@
 };
 }
 
-#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
@@ -137,7 +120,7 @@
         CheckPlacement expected{aux_rect.left+(int)aux_rect.width, aux_rect.top, dx, dy};
 
         auto const spec = WindowSpec::
-            for_menu(connection, dx, dy, mir_pixel_format_argb_8888, parent, &aux_rect, mir_edge_attachment_any)
+            for_menu(connection, dx, dy, parent, &aux_rect, mir_edge_attachment_any)
             .set_event_handler(&CheckPlacement::callback, &expected)
             .set_name(test_name);
 
@@ -156,4 +139,3 @@
         spec.apply_to(child);
     }
 }
-#endif

=== modified file 'test/window_properties.cpp'
--- test/window_properties.cpp	2017-02-21 15:49:58 +0000
+++ test/window_properties.cpp	2017-06-20 16:14:05 +0000
@@ -18,6 +18,7 @@
 
 #include <miral/window_manager_tools.h>
 
+#include <mir/client/surface.h>
 #include <mir/client/window.h>
 #include <mir/client/window_spec.h>
 #include <mir_toolkit/mir_buffer_stream.h>
@@ -45,18 +46,27 @@
     {
         miral::TestServer::SetUp();
         client_connection = connect_client("WindowProperties");
+        surface = Surface{mir_connection_create_render_surface_sync(client_connection, 40, 40)};
     }
 
     void TearDown() override
     {
+        surface.reset();
         client_connection.reset();
         miral::TestServer::TearDown();
     }
 
     Connection client_connection;
+    Surface surface;
 
     std::unique_ptr<TestWindowManagerPolicy> build_window_manager_policy(WindowManagerTools const& tools) override;
 
+    void paint(Surface const& surface)
+    {
+        mir_buffer_stream_swap_buffers_sync(
+            mir_render_surface_get_buffer_stream(surface, 50, 50, mir_pixel_format_argb_8888));
+    }
+
     mir::test::Signal window_ready;
 };
 
@@ -80,12 +90,12 @@
 
 TEST_F(WindowProperties, on_creation_default_shell_chrome_is_normal)
 {
-    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50)
         .set_name(a_window.c_str())
+        .add_surface(surface, 50, 50, 0, 0)
         .create_window();
 
-    mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(window));
+    paint(surface);
     ASSERT_TRUE(window_ready.wait_for(400ms));
 
     invoke_tools([&, this](WindowManagerTools& tools)
@@ -96,13 +106,13 @@
 
 TEST_F(WindowProperties, on_creation_client_setting_shell_chrome_low_is_seen_by_window_manager)
 {
-    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50)
         .set_name(a_window.c_str())
         .set_shell_chrome(mir_shell_chrome_low)
+        .add_surface(surface, 50, 50, 0, 0)
         .create_window();
 
-    mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(window));
+    paint(surface);
     ASSERT_TRUE(window_ready.wait_for(400ms));
 
     invoke_tools([&, this](WindowManagerTools& tools)
@@ -113,16 +123,17 @@
 
 TEST_F(WindowProperties, after_creation_client_setting_shell_chrome_low_is_seen_by_window_manager)
 {
-    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50)
         .set_name(a_window.c_str())
+        .add_surface(surface, 50, 50, 0, 0)
         .create_window();
 
     WindowSpec::for_changes(client_connection)
         .set_shell_chrome(mir_shell_chrome_low)
         .apply_to(window);
 
-    mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(window));
+    paint(surface);
+
     ASSERT_TRUE(window_ready.wait_for(400ms));
 
     invoke_tools([&, this](WindowManagerTools& tools)
@@ -133,17 +144,17 @@
 
 TEST_F(WindowProperties, after_creation_client_setting_shell_chrome_normal_is_seen_by_window_manager)
 {
-    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    auto const window = WindowSpec::for_normal_window(client_connection, 50, 50)
         .set_name(a_window.c_str())
         .set_shell_chrome(mir_shell_chrome_low)
+        .add_surface(surface, 50, 50, 0, 0)
         .create_window();
 
     WindowSpec::for_changes(client_connection)
         .set_shell_chrome(mir_shell_chrome_normal)
         .apply_to(window);
 
-    mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(window));
+    paint(surface);
     ASSERT_TRUE(window_ready.wait_for(400ms));
 
     invoke_tools([&, this](WindowManagerTools& tools)

=== modified file 'test/workspaces.cpp'
--- test/workspaces.cpp	2017-03-30 09:42:17 +0000
+++ test/workspaces.cpp	2017-06-20 16:14:05 +0000
@@ -19,6 +19,7 @@
 #include <miral/workspace_policy.h>
 #include <miral/window_manager_tools.h>
 
+#include <mir/client/surface.h>
 #include <mir/client/window.h>
 #include <mir/client/window_spec.h>
 #include <mir_toolkit/mir_buffer_stream.h>
@@ -65,57 +66,74 @@
     Workspaces& test_fixture;
 };
 
+struct TestWindow : Surface, Window
+{
+    using Surface::operator=;
+    using Window::operator=;
+};
+
 struct Workspaces : public miral::TestServer
 {
-    auto create_window(std::string const& name) -> Window
+    auto create_window(std::string const& name) -> TestWindow
     {
-        auto const window = WindowSpec::for_normal_window(client_connection, 50, 50, mir_pixel_format_argb_8888)
-            .set_buffer_usage(mir_buffer_usage_software)
+        TestWindow result;
+
+        result = Surface{mir_connection_create_render_surface_sync(client_connection, 50, 50)};
+        result = WindowSpec::for_normal_window(client_connection, 50, 50)
             .set_name(name.c_str())
+            .add_surface(result, 50, 50, 0, 0)
             .create_window();
 
-        client_windows[name] = window;
-        init_window(window);
+        client_windows[name] = result;
+        init_window(result);
 
-        return window;
+        return result;
     }
 
-    void init_window(Window const& window)
+    void init_window(TestWindow const& window)
     {
         mir::test::Signal window_ready;
         EXPECT_CALL(policy(), advise_window_ready(_)).WillOnce(InvokeWithoutArgs([&]{ window_ready.raise(); }));
 
-        mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(window));
+        mir_buffer_stream_swap_buffers_sync(
+            mir_render_surface_get_buffer_stream(window, 50, 50, mir_pixel_format_argb_8888));
 
         EXPECT_TRUE(window_ready.wait_for(1s));
     }
 
-    auto create_tip(std::string const& name, Window const& parent) -> Window
+    auto create_tip(std::string const& name, Window const& parent) -> TestWindow
     {
+        TestWindow result;
+
+        result = Surface{mir_connection_create_render_surface_sync(client_connection, 50, 50)};
+
         MirRectangle aux_rect{10, 10, 10, 10};
-        auto const window = WindowSpec::for_tip(client_connection, 50, 50, mir_pixel_format_argb_8888, parent,
-                                                &aux_rect, mir_edge_attachment_any)
-            .set_buffer_usage(mir_buffer_usage_software)
+        result = WindowSpec::for_tip(client_connection, 50, 50, parent, &aux_rect, mir_edge_attachment_any)
             .set_name(name.c_str())
+            .add_surface(result, 50, 50, 0, 0)
             .create_window();
 
-        client_windows[name] = window;
-        init_window(window);
+        client_windows[name] = result;
+        init_window(result);
 
-        return window;
+        return result;
     }
 
-    auto create_dialog(std::string const& name, Window const& parent) -> Window
+    auto create_dialog(std::string const& name, Window const& parent) -> TestWindow
     {
-        auto const window = WindowSpec::for_dialog(client_connection, 50, 50, mir_pixel_format_argb_8888, parent)
-            .set_buffer_usage(mir_buffer_usage_software)
+        TestWindow result;
+
+        result = Surface{mir_connection_create_render_surface_sync(client_connection, 50, 50)};
+
+        result = WindowSpec::for_dialog(client_connection, 50, 50, parent)
             .set_name(name.c_str())
+            .add_surface(result, 50, 50, 0, 0)
             .create_window();
 
-        client_windows[name] = window;
-        init_window(window);
+        client_windows[name] = result;
+        init_window(result);
 
-        return window;
+        return result;
     }
 
     auto create_workspace() -> std::shared_ptr<miral::Workspace>
@@ -202,7 +220,7 @@
 
 private:
     std::mutex mutable mutex;
-    std::map<std::string, Window> client_windows;
+    std::map<std::string, TestWindow> client_windows;
     std::map<std::string, miral::Window> server_windows;
     WorkspacesWindowManagerPolicy* the_policy{nullptr};
 
@@ -466,9 +484,11 @@
 
     {
         auto const another_app = connect_client("another app");
-        auto const window = WindowSpec::for_normal_window(another_app, 50, 50, mir_pixel_format_argb_8888)
-            .set_buffer_usage(mir_buffer_usage_software)
+        TestWindow window;
+        window = Surface{mir_connection_create_render_surface_sync(another_app, 50, 50)};
+        window = WindowSpec::for_normal_window(another_app, 50, 50)
             .set_name(a_window.c_str())
+            .add_surface(window, 50, 50, 0, 0)
             .create_window();
 
         init_window(window);
@@ -527,9 +547,11 @@
     create_window(another_window);
 
     auto const another_app = connect_client("another app");
-    auto const window = WindowSpec::for_normal_window(another_app, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    TestWindow window;
+    window = Surface{mir_connection_create_render_surface_sync(another_app, 50, 50)};
+    window = WindowSpec::for_normal_window(another_app, 50, 50)
         .set_name(a_window.c_str())
+        .add_surface(window, 50, 50, 0, 0)
         .create_window();
 
     init_window(window);
@@ -590,9 +612,11 @@
     create_window(another_window);
 
     auto const another_app = connect_client("another app");
-    auto const window = WindowSpec::for_normal_window(another_app, 50, 50, mir_pixel_format_argb_8888)
-        .set_buffer_usage(mir_buffer_usage_software)
+    TestWindow window;
+    window = Surface{mir_connection_create_render_surface_sync(another_app, 50, 50)};
+    window = WindowSpec::for_normal_window(another_app, 50, 50)
         .set_name(a_window.c_str())
+        .add_surface(window, 50, 50, 0, 0)
         .create_window();
 
     init_window(window);