Merge lp:~kdub/mir/hwc-alpha-support into lp:mir/ubuntu

[Kevin DuBois]

android: support alpha blending overlays together in HWC. bumps android-headers version requirement from 4.2.2 to 4.4.2. also change to premultiplied blending in hwc by default, as thats more in line with the rest of the system.

android: support alpha blending overlays together in HWC. bumps android-headers version requirement from 4.2.2 to 4.4.2. also change to premultiplied blending in hwc by default, as thats more in line with the rest of the system.

=== modified file '3rd_party/android-deps/std/Thread.h'
--- 3rd_party/android-deps/std/Thread.h	2014-05-22 11:31:21 +0000
+++ 3rd_party/android-deps/std/Thread.h	2014-06-18 17:25:24 +0000
@@ -35,6 +35,7 @@
 namespace mir
 {
 void terminate_with_current_exception();
+void set_thread_name(std::string const&);
 }
 
 namespace mir_input
@@ -54,13 +55,15 @@
         int32_t priority = PRIORITY_DEFAULT,
         size_t stack = 0)
     {
-        (void)name; (void)priority; (void)stack;
+        (void)priority; (void)stack;
+        std::string const name_str{name};
 
         status.store(NO_ERROR);
         exit_pending.store(false);
 
-        thread = std::thread([this]() -> void
+        thread = std::thread([name_str,this]() -> void
             {
+                mir::set_thread_name(name_str);
                 try
                 {
                     if (auto result = readyToRun()) status.store(result);
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-06-05 12:55:18 +0000
+++ CMakeLists.txt	2014-06-18 17:25:24 +0000
@@ -27,7 +27,7 @@
 set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
 
 set(MIR_VERSION_MAJOR 0)
-set(MIR_VERSION_MINOR 2) # This should change at least with every MIRSERVER_ABI
+set(MIR_VERSION_MINOR 3) # This should change at least with every MIRSERVER_ABI
 set(MIR_VERSION_PATCH 0)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
=== modified file 'debian/control'
--- debian/control	2014-05-28 07:43:51 +0000
+++ debian/control	2014-06-18 17:25:24 +0000
@@ -27,7 +27,7 @@
                libglm-dev,
                libprotobuf-dev,
                pkg-config,
-               android-headers (>=4.2.2) [i386 amd64 armhf],
+               android-headers (>=4.4.2) [i386 amd64 armhf],
                libhardware-dev [i386 amd64 armhf],
                libandroid-properties-dev [i386 amd64 armhf],
                libgoogle-glog-dev,
@@ -72,7 +72,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver20
+Package: libmirserver21
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -150,7 +150,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver20 (= ${binary:Version}),
+Depends: libmirserver21 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,
 
=== renamed file 'debian/libmirserver20.install' => 'debian/libmirserver21.install'
--- debian/libmirserver20.install	2014-05-07 02:56:33 +0000
+++ debian/libmirserver21.install	2014-06-18 17:25:24 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.20
+usr/lib/*/libmirserver.so.21
 
=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2014-05-28 07:43:51 +0000
+++ examples/CMakeLists.txt	2014-06-18 17:25:24 +0000
@@ -92,6 +92,9 @@
 
 )
 
+add_executable(mir_demo_client_prompt_session prompt_session.c)
+target_link_libraries(mir_demo_client_prompt_session mirclient)
+
 add_library(mirdraw STATIC graphics_utils.cpp)
 target_link_libraries(mirdraw ${GLESv2_LIBRARIES})
 
@@ -143,7 +146,7 @@
   server_configuration.cpp
 )
 
-target_link_libraries(mir_demo_standalone_input_filter  
+target_link_libraries(mir_demo_standalone_input_filter
   mirserver
 )
 
@@ -158,8 +161,9 @@
   mir_demo_client_multiwin
   mir_demo_client_display_config
   mir_demo_client_progressbar
+  mir_demo_client_prompt_session
   mir_demo_standalone_input_filter
-  mir_demo_standalone_render_to_fb 
+  mir_demo_standalone_render_to_fb
   mir_demo_standalone_render_surfaces
 )
 
 
=== modified file 'examples/buffer_render_target.cpp'
--- examples/buffer_render_target.cpp	2014-03-06 06:05:17 +0000
+++ examples/buffer_render_target.cpp	2014-06-18 17:25:24 +0000
@@ -77,7 +77,7 @@
         /* Set up color buffer... */
         glGenTextures(1, &color_tex);
         glBindTexture(GL_TEXTURE_2D, color_tex);
-        buffer.bind_to_texture();
+        buffer.gl_bind_to_texture();
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                GL_TEXTURE_2D, color_tex, 0);
 
 
=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-04-15 05:31:19 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-06-18 17:25:24 +0000
@@ -102,7 +102,7 @@
 
     auto input_platform = mircv::InputPlatform::create();
     input_thread = input_platform->create_input_thread(
-        surface->client_input_fd(), 
+        surface->client_input_fd(),
             std::bind(std::mem_fn(&me::InprocessEGLClient::handle_event), this, std::placeholders::_1));
     input_thread->start();
 
 
=== modified file 'examples/demo-shell/demo_renderer.cpp'
--- examples/demo-shell/demo_renderer.cpp	2014-06-03 17:20:17 +0000
+++ examples/demo-shell/demo_renderer.cpp	2014-06-18 17:25:24 +0000
@@ -18,6 +18,7 @@
 
 #include "demo_renderer.h"
 #include <mir/graphics/renderable.h>
+#include <mir/compositor/destination_alpha.h>
 #include <mir/compositor/recently_used_cache.h>
 #include <cmath>
 
@@ -93,15 +94,6 @@
         {
             Color col = color;
 
-            // Cut out the corner in a circular shape.
-            if (x < cx && y < cy)
-            {
-                int dx = cx - x;
-                int dy = cy - y;
-                if (dx * dx + dy * dy >= radius_sqr)
-                    col.a = 0;
-            }
-
             // Set gradient
             if (y < cy)
             {
@@ -113,6 +105,15 @@
                 col.b += (highlight - col.b) * brighten;
             }
 
+            // Cut out the corner in a circular shape.
+            if (x < cx && y < cy)
+            {
+                int dx = cx - x;
+                int dy = cy - y;
+                if (dx * dx + dy * dy >= radius_sqr)
+                    col = {0, 0, 0, 0};
+            }
+
             image[y * width + x] = col;
         }
     }
@@ -137,10 +138,12 @@
 
 DemoRenderer::DemoRenderer(
     graphics::GLProgramFactory const& program_factory,
-    geometry::Rectangle const& display_area)
+    geometry::Rectangle const& display_area,
+    compositor::DestinationAlpha dest_alpha)
     : GLRenderer(program_factory,
         std::unique_ptr<graphics::GLTextureCache>(new compositor::RecentlyUsedCache()),
-        display_area)
+        display_area,
+        dest_alpha)
     , corner_radius(0.5f)
 {
     shadow_corner_tex = generate_shadow_corner_texture(0.4f);
@@ -157,8 +160,20 @@
 
 void DemoRenderer::begin() const
 {
-    glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+    bool const opaque = destination_alpha() == compositor::DestinationAlpha::opaque;
+    if (opaque)
+        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+    else
+        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glClear(GL_COLOR_BUFFER_BIT);
+<<<<<<< TREE
+=======
+
+    if (opaque)
+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+>>>>>>> MERGE-SOURCE
 }
 
 void DemoRenderer::tessellate(std::vector<graphics::GLPrimitive>& primitives,
@@ -261,7 +276,7 @@
 
     // Shadows always need blending...
     glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 void DemoRenderer::tessellate_frame(std::vector<graphics::GLPrimitive>& primitives,
 
=== modified file 'examples/demo-shell/demo_renderer.h'
--- examples/demo-shell/demo_renderer.h	2014-05-19 02:55:29 +0000
+++ examples/demo-shell/demo_renderer.h	2014-06-18 17:25:24 +0000
@@ -29,7 +29,8 @@
 class DemoRenderer : public compositor::GLRenderer
 {
 public:
-    DemoRenderer(graphics::GLProgramFactory const& factory, geometry::Rectangle const& display_area);
+    DemoRenderer(graphics::GLProgramFactory const& factory, geometry::Rectangle const& display_area,
+        compositor::DestinationAlpha dest_alpha);
     ~DemoRenderer();
 
     void begin() const override;
 
=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2014-04-24 08:42:12 +0000
+++ examples/demo-shell/demo_shell.cpp	2014-06-18 17:25:24 +0000
@@ -53,9 +53,10 @@
     }
 
     std::unique_ptr<compositor::Renderer> create_renderer_for(
-        geometry::Rectangle const& rect) override
+        geometry::Rectangle const& rect,
+        mir::compositor::DestinationAlpha dest_alpha) override
     {
-        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(*gl_program_factory, rect));
+        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(*gl_program_factory, rect, dest_alpha));
     }
 private:
     std::shared_ptr<graphics::GLProgramFactory> const gl_program_factory;
 
=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2014-05-22 11:31:21 +0000
+++ examples/demo-shell/window_manager.cpp	2014-06-18 17:25:24 +0000
@@ -156,6 +156,13 @@
             return true;
         }
         else if ((event.key.modifiers & mir_key_modifier_alt) &&
+                 (event.key.modifiers & mir_key_modifier_ctrl) &&
+                 (event.key.scan_code == KEY_ESC))
+        {
+            std::abort();
+            return true;
+        }
+        else if ((event.key.modifiers & mir_key_modifier_alt) &&
                  (event.key.modifiers & mir_key_modifier_ctrl))
         {
             MirOrientation orientation = mir_orientation_normal;
 
=== modified file 'examples/eglcounter.cpp'
--- examples/eglcounter.cpp	2014-05-07 02:56:33 +0000
+++ examples/eglcounter.cpp	2014-06-18 17:25:24 +0000
@@ -201,7 +201,7 @@
 };
 
 /* Colours from http://design.ubuntu.com/brand/colour-palette */
-#define MID_AUBERGINE 0.368627451f, 0.152941176f, 0.31372549f
+#define MID_AUBERGINE(x) x*0.368627451f, x*0.152941176f, x*0.31372549f
 #define ORANGE        0.866666667f, 0.282352941f, 0.141414141f
 
 int main(int argc, char *argv[])
@@ -254,7 +254,8 @@
         return 2;
     }
 
-    glClearColor(MID_AUBERGINE, mir_eglapp_background_opacity);
+    float const opacity = mir_eglapp_background_opacity;
+    glClearColor(MID_AUBERGINE(opacity), opacity);
     glViewport(0, 0, width, height);
 
     glUseProgram(prog);
 
=== modified file 'examples/eglflash.c'
--- examples/eglflash.c	2013-10-07 09:21:27 +0000
+++ examples/eglflash.c	2014-06-18 17:25:24 +0000
@@ -23,6 +23,11 @@
 #include <unistd.h>
 #include <GLES2/gl2.h>
 
+typedef struct Color
+{
+    GLfloat r, g, b, a;
+} Color;
+
 int main(int argc, char *argv[])
 {
     unsigned int width = 0, height = 0;
@@ -30,20 +35,25 @@
     if (!mir_eglapp_init(argc, argv, &width, &height))
         return 1;
 
+    float const opacity = mir_eglapp_background_opacity;
+    Color red = {opacity, 0.0f, 0.0f, opacity};
+    Color green = {0.0f, opacity, 0.0f, opacity};
+    Color blue = {0.0f, 0.0f, opacity, opacity};
+
     /* This is probably the simplest GL you can do */
     while (mir_eglapp_running())
     {
-        glClearColor(1.0f, 0.0f, 0.0f, mir_eglapp_background_opacity);
-        glClear(GL_COLOR_BUFFER_BIT);
-        mir_eglapp_swap_buffers();
-        sleep(1);
-
-        glClearColor(0.0f, 1.0f, 0.0f, mir_eglapp_background_opacity);
-        glClear(GL_COLOR_BUFFER_BIT);
-        mir_eglapp_swap_buffers();
-        sleep(1);
-
-        glClearColor(0.0f, 0.0f, 1.0f, mir_eglapp_background_opacity);
+        glClearColor(red.r, red.g, red.b, red.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        mir_eglapp_swap_buffers();
+        sleep(1);
+
+        glClearColor(green.r, green.g, green.b, green.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        mir_eglapp_swap_buffers();
+        sleep(1);
+
+        glClearColor(blue.r, blue.g, blue.b, blue.a);
         glClear(GL_COLOR_BUFFER_BIT);
         mir_eglapp_swap_buffers();
         sleep(1);
 
=== modified file 'examples/egltriangle.c'
--- examples/egltriangle.c	2013-10-07 09:21:27 +0000
+++ examples/egltriangle.c	2014-06-18 17:25:24 +0000
@@ -44,7 +44,7 @@
 }
 
 /* Colours from http://design.ubuntu.com/brand/colour-palette */
-#define MID_AUBERGINE 0.368627451f, 0.152941176f, 0.31372549f
+#define MID_AUBERGINE(x) x*0.368627451f, x*0.152941176f, x*0.31372549f
 #define ORANGE        0.866666667f, 0.282352941f, 0.141414141f
 
 int main(int argc, char *argv[])
@@ -105,7 +105,8 @@
         return 2;
     }
 
-    glClearColor(MID_AUBERGINE, mir_eglapp_background_opacity);
+    float const opacity = mir_eglapp_background_opacity;
+    glClearColor(MID_AUBERGINE(opacity), opacity);
     glViewport(0, 0, width, height);
 
     glUseProgram(prog);
 
=== added file 'examples/prompt_session.c'
--- examples/prompt_session.c	1970-01-01 00:00:00 +0000
+++ examples/prompt_session.c	2014-06-18 17:25:24 +0000
@@ -0,0 +1,231 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <nick.dedekind <[e-mail]>
+ */
+
+#define _POSIX_SOURCE
+
+#include "mir_toolkit/mir_client_library.h"
+#include "mir_toolkit/mir_prompt_session.h"
+
+#undef NDEBUG
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <signal.h>
+
+///\page prompt_session.c prompt_session.c: A mir client which starts a prompt session and prompt client app.
+/// mir_demo_client_prompt_session shows the use of mir prompt session API.
+/// This program opens a mir connection and creates a prompt session.
+///\section helper helper()
+/// Opens a mir connection and creates a prompt session
+/// before closing the prompt session and connection.
+///\section prompt_session_app prompt_session_app()
+/// Opens a mir connection and creates a surface
+/// before releasing the surface and closing the connection.
+///\example prompt_session.c A mir client demonstrating prompt sessions.
+///\section MirDemoState MirDemoState
+/// The handles needs to be accessible both to callbacks and to the control function.
+///\snippet prompt_session.c MirDemoState_tag
+///\section Callbacks Callbacks
+///\snippet prompt_session.c Callback_tag
+/// This program creates two processes, both opening a mir connection, one starting
+/// a prompt session with the other process.
+
+///\internal [MirDemoState_tag]
+// Utility structure for the state of a single session.
+typedef struct MirDemoState
+{
+    MirConnection *connection;
+    MirSurface *surface;
+    MirPromptSession *prompt_session;
+    pid_t  child_pid;
+    MirPromptSessionState state;
+
+    int* client_fds;
+    unsigned int client_fd_count;
+} MirDemoState;
+///\internal [MirDemoState_tag]
+
+
+///\internal [Callback_tag]
+// Callback to update MirDemoState on prompt_session_event
+static void prompt_session_event_callback(MirPromptSession* prompt_session,
+                                         MirPromptSessionState state,
+                                         void* context)
+{
+    (void)prompt_session;
+    MirDemoState* demo_state = (MirDemoState*)context;
+    demo_state->state = state;
+
+    printf("helper: Prompt Session state updated to %d\n", state);
+    if (state == mir_prompt_session_state_stopped)
+    {
+        kill(demo_state->child_pid, SIGINT);
+    }
+}
+
+static void client_fd_callback(MirPromptSession* prompt_session, size_t count, int const* fds, void* context)
+{
+    (void)prompt_session;
+    ((MirDemoState*)context)->client_fds = malloc(sizeof(int)*count);
+    unsigned int i = 0;
+    for (; i < count; i++)
+    {
+        ((MirDemoState*)context)->client_fds[i] = fds[i];
+    }
+    ((MirDemoState*)context)->client_fd_count = count;
+}
+///\internal [Callback_tag]
+
+void start_session(const char* server, const char* name, MirDemoState* mcd)
+{
+    // Call mir_connect synchronously
+    mcd->connection = mir_connect_sync(server, name);
+
+    // We expect a connection handle;
+    // we expect it to be valid; and,
+    // we don't expect an error description
+    assert(mcd->connection != NULL);
+    assert(mir_connection_is_valid(mcd->connection));
+    assert(strcmp(mir_connection_get_error_message(mcd->connection), "") == 0);
+    printf("%s: Connected\n", name);
+
+    // We can query information about the platform we're running on
+    {
+        MirPlatformPackage platform_package;
+        platform_package.data_items = -1;
+        platform_package.fd_items = -1;
+
+        mir_connection_get_platform(mcd->connection, &platform_package);
+        assert(0 <= platform_package.data_items);
+        assert(0 <= platform_package.fd_items);
+    }
+}
+
+void stop_session(MirDemoState* mcd, const char* name)
+{
+    if (mcd->surface)
+    {
+        // We should release our surface
+        mir_surface_release_sync(mcd->surface);
+        mcd->surface = 0;
+        printf("%s: Surface released\n", name);
+    }
+
+    // We should release our connection
+    mir_connection_release(mcd->connection);
+    printf("%s: Connection released\n", name);
+}
+
+void helper(const char* server)
+{
+    MirDemoState mcd;
+    mcd.connection = 0;
+    mcd.surface = 0;
+    mcd.prompt_session = 0;
+    mcd.state = mir_prompt_session_state_stopped;
+    mcd.client_fd_count = 0;
+    start_session(server, "helper", &mcd);
+
+    // We create a prompt session
+    mcd.prompt_session = mir_connection_create_prompt_session_sync(mcd.connection, getpid(), prompt_session_event_callback, &mcd);
+    assert(mcd.prompt_session != NULL);
+
+    assert(mcd.state == mir_prompt_session_state_started);
+    puts("helper: Started prompt session");
+
+    mir_wait_for(mir_prompt_session_new_fds_for_prompt_providers(mcd.prompt_session, 1, client_fd_callback, &mcd));
+    assert(mcd.client_fd_count == 1);
+    puts("helper: Added waiting FD");
+
+    printf("helper: Starting child application 'mir_demo_client_basic' with fd://%d\n", mcd.client_fds[0]);
+    mcd.child_pid = fork();
+
+    if (mcd.child_pid == 0)
+    {
+        char buffer[128] = {0};
+        sprintf(buffer, "fd://%d", mcd.client_fds[0]);
+
+        char* args[4];
+        args[0] = "mir_demo_client_basic";
+        args[1] = "-m";
+        args[2] = &buffer[0];
+        args[3] = NULL;
+
+        errno = 0;
+        execvp("mir_demo_client_basic", args);
+        return;
+    }
+
+    int status;
+    printf("helper: Waiting on child application: %d\n", mcd.child_pid);
+    waitpid(mcd.child_pid, &status, 0);
+
+    if (mcd.state == mir_prompt_session_state_started)
+    {
+        mir_prompt_session_release_sync(mcd.prompt_session);
+        mcd.prompt_session = NULL;
+        puts("helper: Stopped prompt session");
+    }
+    else
+    {
+        puts("helper: Prompt session stopped by server");
+    }
+    puts("helper: Done");
+
+    stop_session(&mcd, "helper");
+}
+
+// The main() function deals with parsing arguments and defaults
+int main(int argc, char* argv[])
+{
+    // Some variables for holding command line options
+    char const *server = NULL;
+
+    // Parse the command line
+    {
+        int arg;
+        opterr = 0;
+        while ((arg = getopt (argc, argv, "c:hm:")) != -1)
+        {
+            switch (arg)
+            {
+            case 'm':
+                server = optarg;
+                break;
+
+            case '?':
+            case 'h':
+            default:
+                puts(argv[0]);
+                puts("Usage:");
+                puts("    -m <Mir server socket>");
+                puts("    -h: this help text");
+                return -1;
+            }
+        }
+    }
+
+    helper(server);
+    return 0;
+}
 
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2014-05-28 07:56:16 +0000
+++ examples/render_surfaces.cpp	2014-06-18 17:25:24 +0000
@@ -324,7 +324,7 @@
             {
             }
 
-            bool composite()
+            void composite()
             {
                 while (!created) std::this_thread::yield();
                 stop_watch.stop();
@@ -342,7 +342,6 @@
                     m.step();
 
                 frames++;
-                return false;
             }
 
         private:
 
=== modified file 'include/client/mir_toolkit/mir_connection.h'
--- include/client/mir_toolkit/mir_connection.h	2014-05-22 11:31:21 +0000
+++ include/client/mir_toolkit/mir_connection.h	2014-06-18 17:25:24 +0000
@@ -169,26 +169,6 @@
     MirConnection* connection, MirPixelFormat* formats,
     unsigned const int format_size, unsigned int *num_valid_formats);
 
-/**
- * Allocate some FDs for trusted clients to connect on
- *
- * Trust session helpers need to allocate connection FDs it will pass to
- * trusted clients to use when connecting to the server. The server can
- * then associate them with the trust session.
- *
- *   \warning This API is tentative until the implementation of trust sessions is complete
- *   \param [in] connection     The connection
- *   \param [in] no_of_fds      The number of fds to allocate
- *   \param [in] callback       Callback invoked when request completes
- *   \param [in,out] context    User data passed to the callback function
- *   \return                    A handle that can be passed to mir_wait_for
- */
-MirWaitHandle* mir_connection_new_fds_for_trusted_clients(
-    MirConnection* connection,
-    unsigned int no_of_fds,
-    mir_client_fd_callback callback,
-    void * context);
-
 #ifdef __cplusplus
 }
 /**@}*/
 
=== added file 'include/client/mir_toolkit/mir_prompt_session.h'
--- include/client/mir_toolkit/mir_prompt_session.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/mir_prompt_session.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MIR_TOOLKIT_MIR_PROMPT_SESSION_H_
+#define MIR_TOOLKIT_MIR_PROMPT_SESSION_H_
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Create and start a new prompt session
+ *   \param [in] connection             The connection
+ *   \param [in] application_pid        The process id of the initiating application
+ *   \param [in] state_change_callback  The function to be called when a prompt session state change occurs
+ *   \param [in,out] context            User data passed to the callback functions
+ *   \return                            A handle that can be passed to mir_wait_for
+ */
+MirPromptSession *mir_connection_create_prompt_session_sync(
+    MirConnection* connection,
+    pid_t application_pid,
+    mir_prompt_session_state_change_callback state_change_callback,
+    void *context);
+
+/**
+ * Add a prompt provider process id to the prompt session
+ *   \param [in] prompt_session  The prompt session
+ *   \param [in] provider_pid    The process id of the prompt provider to add
+ *   \return                     True if the process id was added, false otherwise
+ */
+MirBool mir_prompt_session_add_prompt_provider_sync(
+    MirPromptSession *prompt_session,
+    pid_t provider_pid);
+
+/**
+ * Allocate some FDs for prompt providers to connect on
+ *
+ * Prompt helpers need to allocate connection FDs it will pass to
+ * prompt providers to use when connecting to the server. The server can
+ * then associate them with the prompt session.
+ *
+ *   \warning This API is tentative until the implementation of prompt sessions is complete
+ *   \param [in] prompt_session  The prompt session
+ *   \param [in] no_of_fds       The number of fds to allocate
+ *   \param [in] callback        Callback invoked when request completes
+ *   \param [in,out] context     User data passed to the callback function
+ *   \return                     A handle that can be passed to mir_wait_for
+ */
+MirWaitHandle* mir_prompt_session_new_fds_for_prompt_providers(
+    MirPromptSession *prompt_session,
+    unsigned int no_of_fds,
+    mir_client_fd_callback callback,
+    void * context);
+
+/**
+ * Stop and release the specified prompt session
+ *   \param [in] prompt_session  The prompt session
+ */
+void mir_prompt_session_release_sync(MirPromptSession *prompt_session);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_MIR_PROMPT_SESSION_H_ */
 
=== modified file 'include/platform/mir/graphics/buffer.h'
--- include/platform/mir/graphics/buffer.h	2014-03-06 06:05:17 +0000
+++ include/platform/mir/graphics/buffer.h	2014-06-18 17:25:24 +0000
@@ -41,7 +41,8 @@
     virtual geometry::Size size() const = 0;
     virtual geometry::Stride stride() const = 0;
     virtual MirPixelFormat pixel_format() const = 0;
-    virtual void bind_to_texture() = 0;
+    virtual void gl_bind_to_texture() = 0;
+    /* TODO: remove this function, as it is specific to the mesa platform */
     virtual bool can_bypass() const = 0;
 
 protected:
 
=== modified file 'include/platform/mir/graphics/buffer_id.h'
--- include/platform/mir/graphics/buffer_id.h	2014-05-22 09:56:17 +0000
+++ include/platform/mir/graphics/buffer_id.h	2014-06-18 17:25:24 +0000
@@ -27,7 +27,7 @@
 class BufferID
 {
 public:
-    BufferID() : value(id_invalid){}
+    BufferID() noexcept: value(id_invalid){}
     explicit BufferID(uint32_t val) : value(val) {}
     bool is_valid() const { return (id_invalid != value); }
     uint32_t as_uint32_t() const { return value; };
 
=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2014-05-22 09:56:17 +0000
+++ include/platform/mir/graphics/display_buffer.h	2014-06-18 17:25:24 +0000
@@ -67,10 +67,6 @@
     **/
     virtual bool post_renderables_if_optimizable(RenderableList const& renderlist) = 0;
 
-    /** to be deprecated */
-    virtual bool can_bypass() const = 0;
-    virtual void post_update(std::shared_ptr<Buffer> /* bypass_buf */) {}
-
     /** Returns the orientation of the display buffer relative to how the
      *  user should see it (the orientation of the output).
      *  This tells us how much (if any) rotation the renderer needs to do.
@@ -81,6 +77,12 @@
      */
     virtual MirOrientation orientation() const = 0;
 
+    /** Returns true if the display buffer has an alpha channel and the alpha 
+     *  channel will be read from at some point - in which case the renderer
+     *  must produce valid alpha channel content
+     */
+    virtual bool uses_alpha() const = 0;
+
 protected:
     DisplayBuffer() = default;
     DisplayBuffer(DisplayBuffer const& c) = delete;
 
=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2014-05-07 02:56:33 +0000
+++ include/platform/mir/graphics/platform.h	2014-06-18 17:25:24 +0000
@@ -27,6 +27,8 @@
 
 namespace mir
 {
+class EmergencyCleanupRegistry;
+
 namespace frontend
 {
 class Surface;
@@ -116,14 +118,21 @@
  * Function prototype used to return a new graphics platform.
  *
  * \param [in] options options to use for this platform
+ * \param [in] emergency_cleanup_registry object to register emergency shutdown handlers with
  * \param [in] report the object to use to report interesting events from the display subsystem
  *
  * This factory function needs to be implemented by each platform.
  *
  * \ingroup platform_enablement
  */
-extern "C" typedef std::shared_ptr<Platform>(*CreatePlatform)(std::shared_ptr<options::Option> const& options, std::shared_ptr<DisplayReport> const& report);
-extern "C" std::shared_ptr<Platform> create_platform (std::shared_ptr<options::Option> const& options, std::shared_ptr<DisplayReport> const& report);
+extern "C" typedef std::shared_ptr<Platform>(*CreatePlatform)(
+    std::shared_ptr<options::Option> const& options,
+    std::shared_ptr<EmergencyCleanupRegistry> const& emergency_cleanup_registry,
+    std::shared_ptr<DisplayReport> const& report);
+extern "C" std::shared_ptr<Platform> create_platform(
+    std::shared_ptr<options::Option> const& options,
+    std::shared_ptr<EmergencyCleanupRegistry> const& emergency_cleanup_registry,
+    std::shared_ptr<DisplayReport> const& report);
 extern "C" typedef void(*AddPlatformOptions)(
     boost::program_options::options_description& config);
 extern "C" void add_platform_options(
 
=== modified file 'include/server/mir/asio_main_loop.h'
--- include/server/mir/asio_main_loop.h	2014-05-28 07:43:51 +0000
+++ include/server/mir/asio_main_loop.h	2014-06-18 17:25:24 +0000
@@ -58,6 +58,8 @@
                                            std::function<void()> callback) override;
     std::unique_ptr<time::Alarm> notify_at(mir::time::Timestamp time_point,
                                            std::function<void()> callback) override;
+    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> callback) override;
+
     void enqueue(void const* owner, ServerAction const& action);
     void pause_processing_for(void const* owner);
     void resume_processing_for(void const* owner);
 
=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2014-03-26 05:48:59 +0000
+++ include/server/mir/compositor/buffer_stream.h	2014-06-18 17:25:24 +0000
@@ -41,7 +41,9 @@
 public:
     virtual ~BufferStream() = default;
 
-    virtual void swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) = 0;
+    virtual void acquire_client_buffer(
+        std::function<void(graphics::Buffer* buffer)> complete) = 0;
+    virtual void release_client_buffer(graphics::Buffer* buf) = 0;
     virtual std::shared_ptr<graphics::Buffer>
         lock_compositor_buffer(void const* user_id) = 0;
     virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;
 
=== added file 'include/server/mir/compositor/destination_alpha.h'
--- include/server/mir/compositor/destination_alpha.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/compositor/destination_alpha.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2014 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: Alberto Aguirre <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_DESTINATION_ALPHA_H_
+#define MIR_COMPOSITOR_DESTINATION_ALPHA_H_
+
+namespace mir
+{
+namespace compositor
+{
+
+enum class DestinationAlpha
+{
+    generate_from_source,
+    opaque
+};
+
+}
+}
+
+#endif
 
=== modified file 'include/server/mir/compositor/display_buffer_compositor.h'
--- include/server/mir/compositor/display_buffer_compositor.h	2014-03-05 07:31:06 +0000
+++ include/server/mir/compositor/display_buffer_compositor.h	2014-06-18 17:25:24 +0000
@@ -30,9 +30,7 @@
 public:
     virtual ~DisplayBufferCompositor() = default;
 
-    /// Returns true if there is additional work to do. E.g. a composited surface
-    /// has additional buffers ready to composite or during animation
-    virtual bool composite() = 0;
+    virtual void composite() = 0;
 
 protected:
     DisplayBufferCompositor() = default;
 
=== added file 'include/server/mir/compositor/frame_dropping_policy.h'
--- include/server/mir/compositor/frame_dropping_policy.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/compositor/frame_dropping_policy.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_
+#define MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_
+
+#include <functional>
+
+namespace mir
+{
+namespace compositor
+{
+/**
+ * \brief Policy to determine when to drop a frame from a client
+ *
+ * The FrameDroppingPolicy objects are constructed from a
+ * \ref FrameDroppingPolicyFactory
+ *
+ * The frame dropping mechanism is provided as the
+ * \a drop_frames argument of \ref FrameDroppingPolicyFactory::create_policy
+ *
+ * The policy may decide to drop a frame any time that there is an outstanding
+ * swap - namely, when there have been more calls to \ref swap_now_blocking
+ * than to \ref swap_unblocked
+ */
+class FrameDroppingPolicy
+{
+public:
+    virtual ~FrameDroppingPolicy() = default;
+
+    FrameDroppingPolicy(FrameDroppingPolicy const&) = delete;
+    FrameDroppingPolicy& operator=(FrameDroppingPolicy const&) = delete;
+
+    /**
+     * \brief Notify that a swap is now blocking
+     */
+    virtual void swap_now_blocking() = 0;
+    /**
+     * \brief Notify that previous swap is no longer blocking
+     */
+    virtual void swap_unblocked() = 0;
+
+protected:
+    /**
+     * \note FrameDroppingPolicies should not be constructed directly;
+     *       use a \ref FrameDroppingPolicyFactory
+     */
+    FrameDroppingPolicy() = default;
+};
+
+}
+}
+
+#endif // MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_
 
=== added file 'include/server/mir/compositor/frame_dropping_policy_factory.h'
--- include/server/mir/compositor/frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/compositor/frame_dropping_policy_factory.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
+#define MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace compositor
+{
+class FrameDroppingPolicy;
+
+/**
+ * \brief Creator of FrameDroppingPolicies
+ *
+ * The FrameDroppingPolicyFactory is how you go from a means of dropping frames -
+ * the \a drop_frames parameter of \ref create_policy -
+ * to a \ref FrameDroppingPolicy
+ */
+class FrameDroppingPolicyFactory
+{
+public:
+    FrameDroppingPolicyFactory() = default;
+    virtual ~FrameDroppingPolicyFactory() = default;
+
+    FrameDroppingPolicyFactory(FrameDroppingPolicyFactory const&) = delete;
+    FrameDroppingPolicyFactory& operator=(FrameDroppingPolicyFactory const&) = delete;
+
+    /**
+     * \brief Create a FrameDroppingPolicy that will call \a drop_frame when it decides to drop a frame
+     * \param drop_frame    Function to call when a frame needs to be dropped
+     * \return              The policy object.
+     */
+    virtual std::unique_ptr<FrameDroppingPolicy> create_policy(std::function<void(void)> drop_frame) const = 0;
+};
+
+}
+}
+
+#endif // MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
 
=== modified file 'include/server/mir/compositor/gl_renderer.h'
--- include/server/mir/compositor/gl_renderer.h	2014-05-28 07:43:51 +0000
+++ include/server/mir/compositor/gl_renderer.h	2014-06-18 17:25:24 +0000
@@ -37,13 +37,16 @@
 namespace compositor
 {
 
+enum class DestinationAlpha;
+
 class GLRenderer : public Renderer
 {
 public:
     GLRenderer(
         graphics::GLProgramFactory const& program_factory,
         std::unique_ptr<graphics::GLTextureCache> && texture_cache, 
-        geometry::Rectangle const& display_area);
+        geometry::Rectangle const& display_area,
+        DestinationAlpha dest_alpha);
 
     // These are called with a valid GL context:
     void set_viewport(geometry::Rectangle const& rect) override;
@@ -75,6 +78,9 @@
                             graphics::Renderable const& renderable) const;
 
     virtual void render(graphics::Renderable const& renderable) const;
+
+    DestinationAlpha destination_alpha() const;
+
 private:
     std::unique_ptr<graphics::GLProgram> program;
     std::unique_ptr<graphics::GLTextureCache> mutable texture_cache;
@@ -85,7 +91,7 @@
     GLuint transform_uniform_loc;
     GLuint alpha_uniform_loc;
     float rotation;
-
+    DestinationAlpha const dest_alpha;
     geometry::Rectangle viewport;
 };
 
 
=== modified file 'include/server/mir/compositor/renderer_factory.h'
--- include/server/mir/compositor/renderer_factory.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/compositor/renderer_factory.h	2014-06-18 17:25:24 +0000
@@ -31,13 +31,15 @@
 {
 
 class Renderer;
+enum class DestinationAlpha;
 
 class RendererFactory
 {
 public:
     virtual ~RendererFactory() = default;
 
-    virtual std::unique_ptr<Renderer> create_renderer_for(geometry::Rectangle const& rect) = 0;
+    virtual std::unique_ptr<Renderer> create_renderer_for(geometry::Rectangle const& rect,
+        DestinationAlpha dest_alpha) = 0;
 
 protected:
     RendererFactory() = default;
 
=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-05-28 07:56:16 +0000
+++ include/server/mir/default_server_configuration.h	2014-06-18 17:25:24 +0000
@@ -46,6 +46,7 @@
 class Compositor;
 class RendererFactory;
 class CompositorReport;
+class FrameDroppingPolicyFactory;
 }
 namespace frontend
 {
@@ -92,6 +93,8 @@
 class SurfaceStackModel;
 class SurfaceStack;
 class SceneReport;
+class PromptSessionListener;
+class PromptSessionManager;
 }
 namespace graphics
 {
@@ -196,6 +199,7 @@
      *  @{ */
     virtual std::shared_ptr<graphics::GraphicBufferAllocator> the_buffer_allocator();
     virtual std::shared_ptr<compositor::Scene>                  the_scene();
+    virtual std::shared_ptr<compositor::FrameDroppingPolicyFactory> the_frame_dropping_policy_factory();
     /** @} */
 
     /** @name frontend configuration - dependencies
@@ -229,6 +233,8 @@
     virtual std::shared_ptr<scene::PlacementStrategy>   the_placement_strategy();
     virtual std::shared_ptr<scene::SessionListener>     the_session_listener();
     virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
+    virtual std::shared_ptr<scene::PromptSessionListener> the_prompt_session_listener();
+    virtual std::shared_ptr<scene::PromptSessionManager>  the_prompt_session_manager();
     /** @} */
 
     /** @name internal scene configuration
@@ -336,6 +342,7 @@
     CachedPtr<frontend::Screencast> screencast;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
+    CachedPtr<compositor::FrameDroppingPolicyFactory> frame_dropping_policy_factory;
     CachedPtr<scene::SurfaceStack> surface_stack;
     CachedPtr<scene::SceneReport> scene_report;
 
@@ -362,6 +369,8 @@
     CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
     CachedPtr<graphics::GLProgramFactory> gl_program_factory;
     CachedPtr<graphics::GLConfig> gl_config;
+    CachedPtr<scene::PromptSessionListener> prompt_session_listener;
+    CachedPtr<scene::PromptSessionManager> prompt_session_manager;
     CachedPtr<scene::SessionCoordinator> session_coordinator;
     CachedPtr<EmergencyCleanup> emergency_cleanup;
 
 
=== added file 'include/server/mir/frontend/prompt_session.h'
--- include/server/mir/frontend/prompt_session.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/frontend/prompt_session.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_PROMPT_SESSION_H_
+#define MIR_FRONTEND_PROMPT_SESSION_H_
+
+#include "mir_toolkit/common.h"
+
+#include <sys/types.h>
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace mir
+{
+
+namespace frontend
+{
+class PromptSession
+{
+public:
+    virtual ~PromptSession() = default;
+
+protected:
+    PromptSession() = default;
+    PromptSession(const PromptSession&) = delete;
+    PromptSession& operator=(const PromptSession&) = delete;
+};
+
+}
+}
+
+#endif // MIR_FRONTEND_PROMPT_SESSION_H_
 
=== modified file 'include/server/mir/frontend/session_mediator_report.h'
--- include/server/mir/frontend/session_mediator_report.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/frontend/session_mediator_report.h	2014-06-18 17:25:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 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,
@@ -22,6 +22,8 @@
 
 #include <string>
 
+#include <sys/types.h>
+
 namespace mir
 {
 namespace frontend
@@ -46,8 +48,16 @@
 
     virtual void session_configure_surface_called(std::string const& app_name) = 0;
 
+    virtual void session_configure_surface_cursor_called(std::string const& app_name) = 0;
+
     virtual void session_configure_display_called(std::string const& app_name) = 0;
 
+    virtual void session_start_prompt_session_called(std::string const& app_name, pid_t application_process) = 0;
+
+    virtual void session_add_prompt_provider_called(std::string const& app_name, pid_t provider_process) = 0;
+
+    virtual void session_stop_prompt_session_called(std::string const& app_name) = 0;
+
     virtual void session_error(
         std::string const& app_name,
         char const* method,
 
=== modified file 'include/server/mir/frontend/shell.h'
--- include/server/mir/frontend/shell.h	2014-04-15 05:31:19 +0000
+++ include/server/mir/frontend/shell.h	2014-06-18 17:25:24 +0000
@@ -30,11 +30,13 @@
 namespace scene
 {
 struct SurfaceCreationParameters;
+struct PromptSessionCreationParameters;
 }
 namespace frontend
 {
 class EventSink;
 class Session;
+class PromptSession;
 
 class Shell
 {
@@ -54,6 +56,14 @@
 
     virtual void handle_surface_created(std::shared_ptr<Session> const& session) = 0;
 
+    virtual std::shared_ptr<PromptSession> start_prompt_session_for(std::shared_ptr<Session> const& session,
+                                                                  scene::PromptSessionCreationParameters const& params) = 0;
+    virtual void add_prompt_provider_process_for(std::shared_ptr<PromptSession> const& prompt_session,
+                                                                  pid_t process_id) = 0;
+    virtual void add_prompt_provider_for(std::shared_ptr<PromptSession> const& prompt_session,
+                                                                  std::shared_ptr<Session> const& session) = 0;
+    virtual void stop_prompt_session(std::shared_ptr<PromptSession> const& prompt_session) = 0;
+
 protected:
     Shell() = default;
     Shell(const Shell&) = delete;
 
=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2014-05-22 11:31:21 +0000
+++ include/server/mir/frontend/surface.h	2014-06-18 17:25:24 +0000
@@ -20,12 +20,9 @@
 #ifndef MIR_FRONTEND_SURFACE_H_
 #define MIR_FRONTEND_SURFACE_H_
 
-#include "mir/geometry/point.h"
 #include "mir/geometry/size.h"
 #include "mir_toolkit/common.h"
 
-#include <glm/glm.hpp>
-
 #include <memory>
 
 namespace mir
@@ -34,22 +31,17 @@
 {
 class Buffer;
 class InternalSurface;
-}
-namespace input
-{
-class InputChannel;
+class CursorImage;
 }
 
 namespace frontend
 {
-
 class ClientBufferTracker;
 
 class Surface
 {
 public:
-
-    virtual ~Surface() {}
+    virtual ~Surface() = default;
 
     /// Size of the client area of the surface (excluding any decorations)
     virtual geometry::Size client_size() const = 0;
@@ -62,6 +54,8 @@
 
     virtual int configure(MirSurfaceAttrib attrib, int value) = 0;
 
+    virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) = 0;
+
     /**
      *  swap_buffers_blocking() is a convenience wrapper around swap_buffers()
      *  it forces the current thread to block until complete() is called.
 
=== modified file 'include/server/mir/graphics/cursor_images.h'
--- include/server/mir/graphics/cursor_images.h	2014-04-28 23:15:05 +0000
+++ include/server/mir/graphics/cursor_images.h	2014-06-18 17:25:24 +0000
@@ -31,6 +31,8 @@
 {
 class CursorImage;
 
+geometry::Size const default_cursor_size{geometry::Width{64}, geometry::Height{64}};
+
 /// CursorImages is used to lookup cursor images.
 class CursorImages
 {
 
=== added file 'include/server/mir/scene/null_prompt_session_listener.h'
--- include/server/mir/scene/null_prompt_session_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/null_prompt_session_listener.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_NULL_PROMPT_SESSION_LISTENER_H_
+#define MIR_SCENE_NULL_PROMPT_SESSION_LISTENER_H_
+
+#include "mir/scene/prompt_session_listener.h"
+
+namespace mir
+{
+namespace scene
+{
+class NullPromptSessionListener : public PromptSessionListener
+{
+public:
+    void starting(std::shared_ptr<PromptSession> const&) override {}
+    void stopping(std::shared_ptr<PromptSession> const&) override {}
+
+    void prompt_provider_added(PromptSession const&, std::shared_ptr<Session> const&) override {}
+    void prompt_provider_removed(PromptSession const&, std::shared_ptr<Session> const&) override {}
+};
+}
+}
+
+#endif // MIR_SHELL_NULL_PROMPT_SESSION_LISTENER_H_
 
=== modified file 'include/server/mir/scene/null_surface_observer.h'
--- include/server/mir/scene/null_surface_observer.h	2014-05-22 22:44:19 +0000
+++ include/server/mir/scene/null_surface_observer.h	2014-06-18 17:25:24 +0000
@@ -38,6 +38,7 @@
     void frame_posted(int frames_available);
     void alpha_set_to(float alpha);
     void transformation_set_to(glm::mat4 const& t);
+    void cursor_image_set_to(graphics::CursorImage const& image);
     void reception_mode_set_to(input::InputReceptionMode mode);
 
 protected:
 
=== added file 'include/server/mir/scene/prompt_session.h'
--- include/server/mir/scene/prompt_session.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/prompt_session.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_PROMPT_SESSION_H_
+#define MIR_SCENE_PROMPT_SESSION_H_
+
+#include "mir/frontend/prompt_session.h"
+
+namespace mir
+{
+namespace scene
+{
+class Session;
+
+class PromptSession : public frontend::PromptSession
+{
+};
+
+}
+}
+
+#endif // MIR_SHELL_PROMPT_SESSION_H_
 
=== added file 'include/server/mir/scene/prompt_session_creation_parameters.h'
--- include/server/mir/scene/prompt_session_creation_parameters.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/prompt_session_creation_parameters.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_PROMPT_SESSION_CREATION_PARAMETERS_H_
+#define MIR_SCENE_PROMPT_SESSION_CREATION_PARAMETERS_H_
+
+#include <sys/types.h>
+
+namespace mir
+{
+namespace scene
+{
+
+struct PromptSessionCreationParameters
+{
+    pid_t application_pid = 0;
+};
+}
+}
+
+#endif /* MIR_SCENE_PROMPT_SESSION_CREATION_PARAMETERS_H_ */
 
=== added file 'include/server/mir/scene/prompt_session_listener.h'
--- include/server/mir/scene/prompt_session_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/prompt_session_listener.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_PROMPT_SESSION_LISTENER_H_
+#define MIR_SCENE_PROMPT_SESSION_LISTENER_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace scene
+{
+class Session;
+class PromptSession;
+
+class PromptSessionListener
+{
+public:
+    virtual void starting(std::shared_ptr<PromptSession> const& prompt_session) = 0;
+    virtual void stopping(std::shared_ptr<PromptSession> const& prompt_session) = 0;
+
+    virtual void prompt_provider_added(PromptSession const& prompt_session, std::shared_ptr<Session> const& prompt_provider) = 0;
+    virtual void prompt_provider_removed(PromptSession const& prompt_session, std::shared_ptr<Session> const& prompt_provider) = 0;
+
+protected:
+    PromptSessionListener() = default;
+    virtual ~PromptSessionListener() = default;
+
+    PromptSessionListener(const PromptSessionListener&) = delete;
+    PromptSessionListener& operator=(const PromptSessionListener&) = delete;
+};
+
+}
+}
+
+
+#endif // MIR_SCENE_PROMPT_SESSION_LISTENER_H_
 
=== added file 'include/server/mir/scene/prompt_session_manager.h'
--- include/server/mir/scene/prompt_session_manager.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/prompt_session_manager.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_PROMPT_SESSION_MANAGER_H_
+#define MIR_SCENE_PROMPT_SESSION_MANAGER_H_
+
+#include <sys/types.h>
+#include <memory>
+#include <functional>
+
+namespace mir
+{
+namespace scene
+{
+class Session;
+class PromptSession;
+struct PromptSessionCreationParameters;
+
+class PromptSessionManager
+{
+public:
+    virtual ~PromptSessionManager() = default;
+
+    /**
+     * Start a new prompt session
+     *   \param [in] session  The prompt helper session
+     *   \param [in] params   The creation parameters for constructing the prompt session
+     */
+    virtual std::shared_ptr<PromptSession> start_prompt_session_for(std::shared_ptr<Session> const& session,
+                                                                    PromptSessionCreationParameters const& params) const = 0;
+
+    /**
+     * Stop a started prompt session
+     *   \param [in] prompt_session  The prompt session
+     */
+    virtual void stop_prompt_session(std::shared_ptr<PromptSession> const& prompt_session) const = 0;
+
+    /**
+     * Add a prompt provider to an existing prompt session
+     *   \param [in] prompt_session  The prompt session
+     *   \param [in] prompt_provider The prompt provider to add to the prompt session
+     */
+    virtual void add_prompt_provider(std::shared_ptr<PromptSession> const& prompt_session,
+                                     std::shared_ptr<Session> const& prompt_provider) const = 0;
+
+    /**
+     * Add a process id to wait for to the prompt session
+     *   \param [in] prompt_session  The prompt session
+     *   \param [in] process_id      The process id to wait for
+     */
+    virtual void add_prompt_provider_by_pid(std::shared_ptr<PromptSession> const& prompt_session,
+                                            pid_t process_id) const = 0;
+
+    /**
+     * Add a session that may have been expected by a prompt session.
+     *   \param [in] session  The new session that was being expected
+     */
+    virtual void add_expected_session(std::shared_ptr<Session> const& new_session) const = 0;
+
+    /**
+     * Remove a session from all associated prompt sessions
+     *   \param [in] session  The new session that is to be removed
+     */
+    virtual void remove_session(std::shared_ptr<Session> const& session) const = 0;
+
+    /**
+     * Retrieve the application session for a prompt session
+     *   \param [in] prompt_session  The prompt session
+     */
+    virtual std::shared_ptr<Session> application_for(std::shared_ptr<PromptSession> const& prompt_session) const = 0;
+
+    /**
+     * Retrieve the helper session for a prompt session
+     *   \param [in] prompt_session  The prompt session
+     */
+    virtual std::shared_ptr<Session> helper_for(std::shared_ptr<PromptSession> const& prompt_session) const = 0;
+
+    /**
+     * Iterate over all the prompt providers associated with a prompt session
+     *   \param [in] prompt_session  The prompt session
+     *   \param [in] f               The callback function to call for each provider
+     */
+    virtual void for_each_provider_in(std::shared_ptr<PromptSession> const& prompt_session,
+                                      std::function<void(std::shared_ptr<Session> const& prompt_provider)> const& f) const = 0;
+
+protected:
+    PromptSessionManager() = default;
+    PromptSessionManager(const PromptSessionManager&) = delete;
+    PromptSessionManager& operator=(const PromptSessionManager&) = delete;
+};
+
+}
+}
+
+#endif // MIR_SCENE_PROMPT_SESSION_MANAGER_H_
 
=== modified file 'include/server/mir/scene/session.h'
--- include/server/mir/scene/session.h	2014-04-15 05:31:19 +0000
+++ include/server/mir/scene/session.h	2014-06-18 17:25:24 +0000
@@ -40,6 +40,9 @@
     virtual std::shared_ptr<Surface> default_surface() const = 0;
     virtual void set_lifecycle_state(MirLifecycleState state) = 0;
     virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
+
+    virtual void start_prompt_session() = 0;
+    virtual void stop_prompt_session() = 0;
 };
 }
 }
 
=== modified file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	2014-05-22 11:31:21 +0000
+++ include/server/mir/scene/surface.h	2014-06-18 17:25:24 +0000
@@ -31,6 +31,7 @@
 namespace input { class InputChannel; }
 namespace shell { class InputTargeter; }
 namespace geometry { class Rectangle; }
+namespace graphics { class CursorImage; }
 
 namespace scene
 {
@@ -70,6 +71,9 @@
     virtual void set_transformation(glm::mat4 const& t) = 0;
     virtual void set_alpha(float alpha) = 0;
     virtual void force_requests_to_complete() = 0;
+    
+    virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) = 0;
+    virtual std::shared_ptr<graphics::CursorImage> cursor_image() = 0;
 
     virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
     virtual void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) = 0;
 
=== modified file 'include/server/mir/scene/surface_observer.h'
--- include/server/mir/scene/surface_observer.h	2014-05-22 22:44:19 +0000
+++ include/server/mir/scene/surface_observer.h	2014-06-18 17:25:24 +0000
@@ -32,6 +32,10 @@
 struct Size;
 struct Point;
 }
+namespace graphics
+{
+class CursorImage;
+}
 
 namespace scene
 {
@@ -46,6 +50,7 @@
     virtual void alpha_set_to(float alpha) = 0;
     virtual void transformation_set_to(glm::mat4 const& t) = 0;
     virtual void reception_mode_set_to(input::InputReceptionMode mode) = 0;
+    virtual void cursor_image_set_to(graphics::CursorImage const& image) = 0;
 
 protected:
     SurfaceObserver() = default;
 
=== modified file 'include/server/mir/shell/session_coordinator_wrapper.h'
--- include/server/mir/shell/session_coordinator_wrapper.h	2014-05-23 12:59:00 +0000
+++ include/server/mir/shell/session_coordinator_wrapper.h	2014-06-18 17:25:24 +0000
@@ -48,6 +48,20 @@
 
     void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
 
+    std::shared_ptr<frontend::PromptSession> start_prompt_session_for(
+        std::shared_ptr<frontend::Session> const& session,
+        scene::PromptSessionCreationParameters const& params) override;
+
+    void add_prompt_provider_process_for(
+        std::shared_ptr<frontend::PromptSession> const& prompt_session,
+        pid_t process_id) override;
+
+    void add_prompt_provider_for(
+        std::shared_ptr<frontend::PromptSession> const& prompt_session,
+        std::shared_ptr<frontend::Session> const& session) override;
+
+    void stop_prompt_session(std::shared_ptr<frontend::PromptSession> const& prompt_session) override;
+
 protected:
     std::shared_ptr<scene::SessionCoordinator> const wrapped;
 };
 
=== modified file 'include/server/mir/time/timer.h'
--- include/server/mir/time/timer.h	2014-05-22 09:56:17 +0000
+++ include/server/mir/time/timer.h	2014-06-18 17:25:24 +0000
@@ -58,7 +58,14 @@
      */
     virtual std::unique_ptr<Alarm> notify_at(Timestamp time_point,
                                              std::function<void()> callback) = 0;
-
+    /**
+     * \brief Create an Alarm that will not fire until scheduled
+     *
+     * \param callback  Function to call when the Alarm signals
+     *
+     * \return A handle to an Alarm that can later be scheduled
+     */
+    virtual std::unique_ptr<Alarm> create_alarm(std::function<void()> callback) = 0;
 
     Timer(Timer const&) = delete;
     Timer& operator=(Timer const&) = delete;
 
=== added file 'include/shared/mir/thread_name.h'
--- include/shared/mir/thread_name.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/thread_name.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_THREAD_NAME_H_
+#define MIR_THREAD_NAME_H_
+
+#include <string>
+
+namespace mir
+{
+void set_thread_name(std::string const& name);
+}
+
+#endif /* MIR_THREAD_NAME_H_ */
 
=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2014-05-22 11:31:21 +0000
+++ include/shared/mir_toolkit/client_types.h	2014-06-18 17:25:24 +0000
@@ -46,6 +46,7 @@
 typedef struct MirConnection MirConnection;
 typedef struct MirSurface MirSurface;
 typedef struct MirScreencast MirScreencast;
+typedef struct MirPromptSession MirPromptSession;
 
 /**
  * Returned by asynchronous functions. Must not be free'd by
@@ -105,7 +106,7 @@
 
 /**
  * Callback called when a request for client file descriptors completes
- *   \param [in] connection     The connection associated with the display change
+ *   \param [in] prompt_session  The prompt session
  *   \param [in] count          The number of FDs allocated
  *   \param [in] fds            Array of FDs
  *   \param [in,out] context    The context provided by client
@@ -114,7 +115,7 @@
  */
 
 typedef void (*mir_client_fd_callback)(
-    MirConnection* connection, size_t count, int const* fds, void* context);
+    MirPromptSession *prompt_session, size_t count, int const* fds, void* context);
 
 /**
  * MirBufferUsage specifies how a surface can and will be used. A "hardware"
@@ -319,6 +320,31 @@
  */
 typedef void (*mir_screencast_callback)(MirScreencast *screencast, void *client_context);
 
+/**
+ * Callback member of MirPromptSession for handling of prompt sessions.
+ *   \param [in] prompt_provider  The prompt session associated with the callback
+ *   \param [in,out] context      The context provided by the client
+ */
+typedef void (*mir_prompt_session_callback)(MirPromptSession* prompt_provider, void* context);
+
+/**
+ * Callback member of MirPromptSession for adding prompt providers
+ *   \param [in] prompt_provider  The prompt session associated with the callback
+ *   \param [in] added            True if the session was added, false otherwise
+ *   \param [in,out] context      The context provided by the client
+ */
+typedef void (*mir_prompt_session_add_prompt_provider_callback)(
+    MirPromptSession* prompt_provider, MirBool added, void* context);
+
+/**
+ * Callback member of MirPromptSession for handling of prompt sessions events.
+ *   \param [in] prompt_provider  The prompt session associated with the callback
+ *   \param [in] state            The state of the prompt session
+ *   \param [in,out] context      The context provided by the client
+ */
+typedef void (*mir_prompt_session_state_change_callback)(
+    MirPromptSession* prompt_provider, MirPromptSessionState state, void* context);
+
 #ifdef __cplusplus
 }
 /**@}*/
 
=== modified file 'include/shared/mir_toolkit/common.h'
--- include/shared/mir_toolkit/common.h	2014-05-05 09:02:17 +0000
+++ include/shared/mir_toolkit/common.h	2014-06-18 17:25:24 +0000
@@ -88,6 +88,12 @@
     mir_power_mode_off /* Powered down. */
 } MirPowerMode;
 
+typedef enum MirPromptSessionState
+{
+    mir_prompt_session_state_stopped = 0,
+    mir_prompt_session_state_started
+} MirPromptSessionState;
+
 /**
  * The order of components in a format enum matches the
  * order of the components as they would be written in an
 
=== modified file 'include/shared/mir_toolkit/event.h'
--- include/shared/mir_toolkit/event.h	2014-03-06 06:05:17 +0000
+++ include/shared/mir_toolkit/event.h	2014-06-18 17:25:24 +0000
@@ -40,7 +40,8 @@
     mir_event_type_key,
     mir_event_type_motion,
     mir_event_type_surface,
-    mir_event_type_resize
+    mir_event_type_resize,
+    mir_event_type_prompt_session_state_change
 } MirEventType;
 
 typedef enum {
@@ -204,6 +205,13 @@
     int height;
 } MirResizeEvent;
 
+typedef struct
+{
+    MirEventType type;
+
+    MirPromptSessionState new_state;
+} MirPromptSessionEvent;
+
 typedef union
 {
     MirEventType    type;
@@ -211,6 +219,7 @@
     MirMotionEvent  motion;
     MirSurfaceEvent surface;
     MirResizeEvent  resize;
+    MirPromptSessionEvent  prompt_session;
 } MirEvent;
 
 #ifdef __cplusplus
 
=== added file 'include/test/mir_test/barrier.h'
--- include/test/mir_test/barrier.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/barrier.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2014 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 MIR_TEST_BARRIER_H_
+#define MIR_TEST_BARRIER_H_
+
+#include <mutex>
+#include <condition_variable>
+
+namespace mir
+{
+namespace test
+{
+class Barrier
+{
+public:
+    explicit Barrier(unsigned wait_threads) : wait_threads{wait_threads} {}
+
+    void reset(unsigned threads)
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+        wait_threads  = threads;
+    }
+
+    void ready()
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+        --wait_threads;
+        cv.notify_all();
+        if (!cv.wait_for(lock, std::chrono::minutes(1), [&]{ return wait_threads == 0; }))
+            throw std::runtime_error("Timeout");
+    }
+
+private:
+    Barrier(Barrier const&) = default;
+    Barrier& operator=(Barrier const&) = default;
+    unsigned wait_threads;
+    std::mutex mutex;
+    std::condition_variable cv;
+};
+}
+}
+
+
+
+#endif /* MIR_TEST_BARRIER_H_ */
 
=== added file 'include/test/mir_test/current_thread_name.h'
--- include/test/mir_test/current_thread_name.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/current_thread_name.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_CURRENT_THREAD_NAME_H_
+#define MIR_TEST_CURRENT_THREAD_NAME_H_
+
+#include <string>
+
+namespace mir
+{
+namespace test
+{
+
+std::string current_thread_name();
+
+}
+}
+
+#endif
 
=== added file 'include/test/mir_test/fake_clock.h'
--- include/test/mir_test/fake_clock.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/fake_clock.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_TEST_FAKE_CLOCK_H_
+#define MIR_TEST_FAKE_CLOCK_H_
+
+#include <chrono>
+#include <functional>
+#include <list>
+
+namespace mir
+{
+namespace test
+{
+/**
+ * @brief An invasive time source for Mocks/Stubs/Fakes that depend on timing
+ */
+class FakeClock
+{
+public:
+    typedef std::chrono::nanoseconds duration;
+    typedef duration::rep rep;
+    typedef duration::period period;
+    typedef std::chrono::time_point<FakeClock, duration> time_point;
+
+    static constexpr bool is_steady = false;
+    time_point now() const;
+
+    FakeClock();
+    /**
+     * \brief Advance the fake clock
+     * \note Advancing by a negative duration will move the clock backwards
+     */
+    template<typename rep, typename period>
+    void advance_time(std::chrono::duration<rep, period> by)
+    {
+        advance_time_ns(std::chrono::duration_cast<std::chrono::nanoseconds>(by));
+    }
+
+    /**
+     * \brief Register an event callback when the time is changed
+     * \param cb    Function to call when the time is changed.
+     *              This function is called with the new time.
+     *              If the function returns false, it will no longer be called
+     *              on subsequent time changes.
+     */
+    void register_time_change_callback(std::function<bool(time_point)> cb);
+private:
+    void advance_time_ns(std::chrono::nanoseconds by);
+    std::chrono::nanoseconds current_time;
+    std::list<std::function<bool(time_point)>> callbacks;
+};
+
+}
+}
+
+#endif // MIR_TEST_FAKE_CLOCK_H_
 
=== added file 'include/test/mir_test/signal.h'
--- include/test/mir_test/signal.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/signal.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_TEST_SIGNAL_H_
+#define MIR_TEST_SIGNAL_H_
+
+#include <condition_variable>
+#include <chrono>
+#include <mutex>
+
+namespace mir
+{
+namespace test
+{
+/**
+ * @brief A threadsafe, waitable signal
+ */
+class Signal
+{
+public:
+    Signal();
+
+    void raise();
+    bool raised();
+
+    void wait();
+    template<typename rep, typename period>
+    bool wait_for(std::chrono::duration<rep, period> delay)
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+        return cv.wait_for(lock, delay, [this]() { return signalled; });
+    }
+    template<class Clock, class Duration>
+    bool wait_until(std::chrono::time_point<Clock, Duration> const& time)
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+        return cv.wait_until(lock, time, [this]() { return signalled; });
+    }
+
+private:
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool signalled;
+};
+}
+}
+
+#endif // MIR_TEST_SIGNAL_H_
 
=== modified file 'include/test/mir_test/test_protobuf_client.h'
--- include/test/mir_test/test_protobuf_client.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test/test_protobuf_client.h	2014-06-18 17:25:24 +0000
@@ -21,6 +21,7 @@
 #define MIR_TEST_TEST_CLIENT_H_
 
 #include "mir_protobuf.pb.h"
+#include "wait_condition.h"
 
 #include <gmock/gmock.h>
 
@@ -49,6 +50,9 @@
     mir::protobuf::Connection connection;
     mir::protobuf::DisplayConfiguration disp_config;
     mir::protobuf::DisplayConfiguration disp_config_response;
+    mir::protobuf::PromptSessionParameters prompt_session_parameters;
+    mir::protobuf::PromptProvider prompt_provider;
+    mir::protobuf::Void prompt_session;
 
     MOCK_METHOD0(connect_done, void());
     MOCK_METHOD0(create_surface_done, void());
@@ -57,6 +61,9 @@
     MOCK_METHOD0(disconnect_done, void());
     MOCK_METHOD0(drm_auth_magic_done, void());
     MOCK_METHOD0(display_configure_done, void());
+    MOCK_METHOD0(prompt_session_start_done, void());
+    MOCK_METHOD0(prompt_session_add_prompt_provider_done, void());
+    MOCK_METHOD0(prompt_session_stop_done, void());
 
     void on_connect_done();
 
@@ -94,6 +101,12 @@
 
     void wait_for_configure_display_done();
 
+    void wait_for_prompt_session_start_done();
+
+    void wait_for_prompt_session_add_prompt_provider_done();
+
+    void wait_for_prompt_session_stop_done();
+
     const int maxwait;
     std::atomic<bool> connect_done_called;
     std::atomic<bool> create_surface_called;
@@ -104,6 +117,10 @@
     std::atomic<bool> configure_display_done_called;
     std::atomic<bool> tfd_done_called;
 
+    WaitCondition wc_prompt_session_start;
+    WaitCondition wc_prompt_session_add;
+    WaitCondition wc_prompt_session_stop;
+
     std::atomic<int> connect_done_count;
     std::atomic<int> create_surface_done_count;
     std::atomic<int> disconnect_done_count;
 
=== modified file 'include/test/mir_test_doubles/fake_ipc_factory.h'
--- include/test/mir_test_doubles/fake_ipc_factory.h	2014-05-13 10:03:15 +0000
+++ include/test/mir_test_doubles/fake_ipc_factory.h	2014-06-18 17:25:24 +0000
@@ -40,24 +40,26 @@
         std::shared_ptr<frontend::DisplayChanger> const& changer,
         std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<frontend::SessionMediatorReport> const& sm_report,
-        const std::shared_ptr<frontend::EventSink>& sink,
-        const std::shared_ptr<frontend::Screencast>& effective_screencast,
-        const frontend::ConnectionContext& connection_context)
+        std::shared_ptr<frontend::EventSink> const& sink,
+        std::shared_ptr<frontend::Screencast> const& effective_screencast,
+        frontend::ConnectionContext const& connection_context,
+        std::shared_ptr<graphics::CursorImages> const& cursor_images)
     {
         return frontend::DefaultIpcFactory::make_mediator(
             shell, graphics_platform, changer, buffer_allocator,
-            sm_report, sink, effective_screencast, connection_context);
+            sm_report, sink, effective_screencast, connection_context, cursor_images);
     }
 
-    MOCK_METHOD8(make_mediator, std::shared_ptr<frontend::detail::DisplayServer>(
+    MOCK_METHOD9(make_mediator, std::shared_ptr<frontend::detail::DisplayServer>(
         std::shared_ptr<frontend::Shell> const& shell,
         std::shared_ptr<graphics::Platform> const& graphics_platform,
         std::shared_ptr<frontend::DisplayChanger> const& changer,
         std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<frontend::SessionMediatorReport> const& sm_report,
-        const std::shared_ptr<frontend::EventSink>& sink,
-        const std::shared_ptr<frontend::Screencast>& effective_screencast,
-        const frontend::ConnectionContext& connection_context));
+        std::shared_ptr<frontend::EventSink> const& sink,
+        std::shared_ptr<frontend::Screencast> const& effective_screencast,
+        frontend::ConnectionContext const& connection_context,
+        std::shared_ptr<graphics::CursorImages> const& cursor_images));
 };
 }
 }
 
=== modified file 'include/test/mir_test_doubles/fake_renderable.h'
--- include/test/mir_test_doubles/fake_renderable.h	2014-05-07 02:56:33 +0000
+++ include/test/mir_test_doubles/fake_renderable.h	2014-06-18 17:25:24 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_FAKE_RENDERABLE_H_
 #define MIR_TEST_DOUBLES_FAKE_RENDERABLE_H_
 
+#include "stub_buffer.h"
 #include "mir/graphics/renderable.h"
 #define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_transform.hpp>
@@ -34,12 +35,36 @@
 class FakeRenderable : public graphics::Renderable
 {
 public:
-    FakeRenderable(int x, int y, int width, int height,
-                   float opacity=1.0f,
-                   bool rectangular=true,
-                   bool visible=true,
-                   bool posted=true)
-        : rect{{x, y}, {width, height}},
+    FakeRenderable(int x, int y, int width, int height)
+        : FakeRenderable{geometry::Rectangle{{x,y},{width,height}}}
+    {
+    }
+    FakeRenderable(geometry::Rectangle display_area)
+        : FakeRenderable{display_area, 1.0f, true, true, true}
+    {
+    }
+
+    FakeRenderable(geometry::Rectangle display_area,
+                   float opacity)
+        : FakeRenderable{display_area, opacity, true, true, true}
+    {
+    }
+
+    FakeRenderable(geometry::Rectangle display_area,
+                   float opacity,
+                   bool rectangular,
+                   bool visible)
+        : FakeRenderable{display_area, opacity, rectangular, visible, true}
+    {
+    }
+
+    FakeRenderable(geometry::Rectangle display_area,
+                   float opacity,
+                   bool rectangular,
+                   bool visible,
+                   bool posted)
+        : buf{std::make_shared<StubBuffer>()},
+          rect(display_area),
           opacity(opacity),
           rectangular(rectangular),
           visible_(visible),
 
=== modified file 'include/test/mir_test_doubles/mock_buffer.h'
--- include/test/mir_test_doubles/mock_buffer.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_buffer.h	2014-06-18 17:25:24 +0000
@@ -63,7 +63,7 @@
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());
     MOCK_CONST_METHOD0(native_buffer_handle, std::shared_ptr<graphics::NativeBuffer>());
 
-    MOCK_METHOD0(bind_to_texture, void());
+    MOCK_METHOD0(gl_bind_to_texture, void());
     MOCK_CONST_METHOD0(id, graphics::BufferID());
 
     MOCK_CONST_METHOD0(can_bypass, bool());
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2014-04-14 19:35:21 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2014-06-18 17:25:24 +0000
@@ -44,7 +44,8 @@
         ON_CALL(*this, buffers_ready_for_compositor())
             .WillByDefault(testing::Invoke(this, &MockBufferStream::buffers_ready));
     }
-    MOCK_METHOD2(swap_client_buffers, void(graphics::Buffer*, std::function<void(graphics::Buffer*)> completee));
+    MOCK_METHOD1(acquire_client_buffer, void(std::function<void(graphics::Buffer* buffer)>));
+    MOCK_METHOD1(release_client_buffer, void(graphics::Buffer*));
     MOCK_METHOD1(lock_compositor_buffer,
                  std::shared_ptr<graphics::Buffer>(void const*));
     MOCK_METHOD0(lock_snapshot_buffer, std::shared_ptr<graphics::Buffer>());
 
=== modified file 'include/test/mir_test_doubles/mock_display_buffer.h'
--- include/test/mir_test_doubles/mock_display_buffer.h	2014-05-22 09:56:17 +0000
+++ include/test/mir_test_doubles/mock_display_buffer.h	2014-06-18 17:25:24 +0000
@@ -36,8 +36,6 @@
     MockDisplayBuffer()
     {
         using namespace testing;
-        ON_CALL(*this, can_bypass())
-            .WillByDefault(Return(false));
         ON_CALL(*this, view_area())
             .WillByDefault(Return(geometry::Rectangle{{0,0},{0,0}}));
     }
@@ -45,9 +43,9 @@
     MOCK_METHOD0(make_current, void());
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(post_update, void());
-    MOCK_CONST_METHOD0(can_bypass, bool());
-    MOCK_METHOD1(post_renderables_if_optimizable, bool(graphics::RenderableList const&)); 
+    MOCK_METHOD1(post_renderables_if_optimizable, bool(graphics::RenderableList const&));
     MOCK_CONST_METHOD0(orientation, MirOrientation());
+    MOCK_CONST_METHOD0(uses_alpha, bool());
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_display_device.h'
--- include/test/mir_test_doubles/mock_display_device.h	2014-05-20 20:01:43 +0000
+++ include/test/mir_test_doubles/mock_display_device.h	2014-06-18 17:25:24 +0000
@@ -36,12 +36,11 @@
 public:
     ~MockDisplayDevice() noexcept {}
     MOCK_METHOD1(mode, void(MirPowerMode));
-    MOCK_METHOD1(render_gl, void(graphics::android::SwappingGLContext const&));
-    MOCK_METHOD3(prepare_overlays, void(
+    MOCK_METHOD1(post_gl, void(graphics::android::SwappingGLContext const&));
+    MOCK_METHOD3(post_overlays, bool(
         graphics::android::SwappingGLContext const&,
         graphics::RenderableList const&,
         graphics::android::RenderableListCompositor const&));
-    MOCK_METHOD1(post, void(graphics::Buffer const&));
     MOCK_CONST_METHOD1(apply_orientation, bool(MirOrientation));
 };
 }
 
=== added file 'include/test/mir_test_doubles/mock_frame_dropping_policy_factory.h'
--- include/test/mir_test_doubles/mock_frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_frame_dropping_policy_factory.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+
+#ifndef MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_
+#define MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_
+
+#include "mir/compositor/frame_dropping_policy_factory.h"
+#include "mir/compositor/frame_dropping_policy.h"
+
+#include <unordered_set>
+#include <functional>
+
+#include <gmock/gmock.h>
+
+namespace mc = mir::compositor;
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockFrameDroppingPolicyFactory;
+
+class MockFrameDroppingPolicy : public mc::FrameDroppingPolicy
+{
+public:
+    MockFrameDroppingPolicy(std::function<void(void)> callback,
+                            MockFrameDroppingPolicyFactory const* parent);
+    ~MockFrameDroppingPolicy();
+
+    MOCK_METHOD0(swap_now_blocking, void(void));
+    MOCK_METHOD0(swap_unblocked, void(void));
+
+    void trigger();
+
+private:
+    friend class MockFrameDroppingPolicyFactory;
+    void parent_destroyed();
+
+    std::function<void(void)> callback;
+    MockFrameDroppingPolicyFactory const* parent;
+};
+
+class MockFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
+{
+public:
+    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(std::function<void(void)> drop_frame) const override;
+
+    ~MockFrameDroppingPolicyFactory();
+
+    void trigger_policies() const;
+
+private:
+    friend class MockFrameDroppingPolicy;
+
+    void policy_destroyed(MockFrameDroppingPolicy* policy) const;
+    mutable std::unordered_set<MockFrameDroppingPolicy*> policies;
+};
+
+}
+}
+}
+
+
+#endif // MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_
 
=== modified file 'include/test/mir_test_doubles/mock_frontend_surface.h'
--- include/test/mir_test_doubles/mock_frontend_surface.h	2014-05-22 11:31:21 +0000
+++ include/test/mir_test_doubles/mock_frontend_surface.h	2014-06-18 17:25:24 +0000
@@ -46,6 +46,8 @@
 
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
+    
+    MOCK_METHOD1(set_cursor_image, void(std::shared_ptr<graphics::CursorImage> const&));
 
     MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
 };
 
=== added file 'include/test/mir_test_doubles/mock_prompt_session_listener.h'
--- include/test/mir_test_doubles/mock_prompt_session_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_prompt_session_listener.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_PROMPT_SESSION_LISTENER_H_
+#define MIR_TEST_DOUBLES_MOCK_PROMPT_SESSION_LISTENER_H_
+
+#include "mir/scene/prompt_session_listener.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockPromptSessionListener : public scene::PromptSessionListener
+{
+    virtual ~MockPromptSessionListener() noexcept(true) {}
+
+    MOCK_METHOD1(starting, void(std::shared_ptr<scene::PromptSession> const&));
+    MOCK_METHOD1(stopping, void(std::shared_ptr<scene::PromptSession> const&));
+
+    MOCK_METHOD2(prompt_provider_added, void(scene::PromptSession const&, std::shared_ptr<scene::Session> const&));
+    MOCK_METHOD2(prompt_provider_removed, void(scene::PromptSession const&, std::shared_ptr<scene::Session> const&));
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_MOCK_PROMPT_SESSION_LISTENER_H_
 
=== modified file 'include/test/mir_test_doubles/mock_scene_session.h'
--- include/test/mir_test_doubles/mock_scene_session.h	2014-05-22 11:31:21 +0000
+++ include/test/mir_test_doubles/mock_scene_session.h	2014-06-18 17:25:24 +0000
@@ -52,6 +52,9 @@
     MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
 
     MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
+
+    MOCK_METHOD0(start_prompt_session, void());
+    MOCK_METHOD0(stop_prompt_session, void());
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_shell.h'
--- include/test/mir_test_doubles/mock_shell.h	2014-04-15 05:31:19 +0000
+++ include/test/mir_test_doubles/mock_shell.h	2014-06-18 17:25:24 +0000
@@ -22,6 +22,7 @@
 #include "mir/scene/surface_creation_parameters.h"
 #include "mir/frontend/shell.h"
 #include "mir/frontend/surface_id.h"
+#include "mir/scene/prompt_session_creation_parameters.h"
 
 #include <gmock/gmock.h>
 
@@ -43,6 +44,17 @@
 
     MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, scene::SurfaceCreationParameters const&));
     MOCK_METHOD1(handle_surface_created, void(std::shared_ptr<frontend::Session> const&));
+
+    MOCK_METHOD2(start_prompt_session_for, std::shared_ptr<frontend::PromptSession>(
+        std::shared_ptr<frontend::Session> const&,
+        scene::PromptSessionCreationParameters const&));
+    MOCK_METHOD2(add_prompt_provider_process_for, void(
+        std::shared_ptr<frontend::PromptSession> const&,
+        pid_t));
+    MOCK_METHOD2(add_prompt_provider_for, void(
+        std::shared_ptr<frontend::PromptSession> const&,
+        std::shared_ptr<frontend::Session> const&));
+    MOCK_METHOD1(stop_prompt_session, void(std::shared_ptr<frontend::PromptSession> const&));
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2014-05-07 02:56:33 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2014-06-18 17:25:24 +0000
@@ -41,6 +41,7 @@
             {},
             {},
             {},
+            {},
             mir::report::null_scene_report())
     {
     }
 
=== modified file 'include/test/mir_test_doubles/mock_swapping_gl_context.h'
--- include/test/mir_test_doubles/mock_swapping_gl_context.h	2014-02-21 16:51:45 +0000
+++ include/test/mir_test_doubles/mock_swapping_gl_context.h	2014-06-18 17:25:24 +0000
@@ -31,6 +31,7 @@
 struct MockSwappingGLContext : public graphics::android::SwappingGLContext
 {
     MOCK_CONST_METHOD0(swap_buffers, void());
+    MOCK_CONST_METHOD0(last_rendered_buffer, std::shared_ptr<graphics::Buffer>());
 };
 
 }
 
=== added file 'include/test/mir_test_doubles/mock_timer.h'
--- include/test/mir_test_doubles/mock_timer.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_timer.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_TIMER_H_
+#define MIR_TEST_DOUBLES_MOCK_TIMER_H_
+
+#include "mir/time/timer.h"
+#include "mir_test/fake_clock.h"
+#include <memory>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class FakeTimer : public mir::time::Timer
+{
+public:
+    FakeTimer(std::shared_ptr<FakeClock> const& clock);
+
+    std::unique_ptr<time::Alarm> notify_in(std::chrono::milliseconds delay,
+                                           std::function<void(void)> callback) override;
+    std::unique_ptr<time::Alarm> notify_at(time::Timestamp time_point,
+                                           std::function<void(void)> callback) override;
+    std::unique_ptr<time::Alarm> create_alarm(std::function<void ()> callback) override;
+
+private:
+    std::shared_ptr<FakeClock> const clock;
+};
+
+}
+}
+}
+
+#endif // MIR_TEST_DOUBLES_MOCK_TIMER_H_
 
=== added file 'include/test/mir_test_doubles/mock_virtual_terminal.h'
--- include/test/mir_test_doubles/mock_virtual_terminal.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_virtual_terminal.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_VIRTUAL_TERMINAL_H_
+#define MIR_TEST_DOUBLES_MOCK_VIRTUAL_TERMINAL_H_
+
+#include "src/platform/graphics/mesa/virtual_terminal.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockVirtualTerminal : public graphics::mesa::VirtualTerminal
+{
+public:
+    MOCK_METHOD0(set_graphics_mode, void());
+    MOCK_METHOD3(register_switch_handlers,
+                 void(graphics::EventHandlerRegister&,
+                      std::function<bool()> const&,
+                      std::function<bool()> const&));
+    MOCK_METHOD0(restore, void());
+};
+
+}
+}
+}
+
+#endif
 
=== added file 'include/test/mir_test_doubles/null_client_event_sink.h'
--- include/test/mir_test_doubles/null_client_event_sink.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_client_event_sink.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2012 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: Nick Dedekink <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_CLIENT_EVENT_SINK_H_
+#define MIR_TEST_DOUBLES_NULL_CLIENT_EVENT_SINK_H_
+
+#include "src/client/event_sink.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+class NullClientEventSink : public client::EventSink
+{
+public:
+    void handle_event(MirEvent const&) override {}
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_CLIENT_EVENT_SINK_H_ */
 
=== modified file 'include/test/mir_test_doubles/null_display_buffer.h'
--- include/test/mir_test_doubles/null_display_buffer.h	2014-05-22 09:56:17 +0000
+++ include/test/mir_test_doubles/null_display_buffer.h	2014-06-18 17:25:24 +0000
@@ -35,9 +35,9 @@
     void make_current() {}
     void release_current() {}
     void post_update() {}
-    bool can_bypass() const override { return false; }
     bool post_renderables_if_optimizable(graphics::RenderableList const&) { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
+    bool uses_alpha() const override { return false; }
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/null_display_buffer_compositor_factory.h'
--- include/test/mir_test_doubles/null_display_buffer_compositor_factory.h	2014-04-08 13:12:47 +0000
+++ include/test/mir_test_doubles/null_display_buffer_compositor_factory.h	2014-06-18 17:25:24 +0000
@@ -37,7 +37,7 @@
     {
         struct NullDisplayBufferCompositor : compositor::DisplayBufferCompositor
         {
-            bool composite() { return false; }
+            void composite() {}
         };
 
         auto raw = new NullDisplayBufferCompositor{};
 
=== added file 'include/test/mir_test_doubles/null_pixel_buffer.h'
--- include/test/mir_test_doubles/null_pixel_buffer.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_pixel_buffer.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_PIXEL_BUFFER_H_
+#define MIR_TEST_DOUBLES_NULL_PIXEL_BUFFER_H_
+
+#include "src/server/scene/pixel_buffer.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct NullPixelBuffer : public scene::PixelBuffer
+{
+    void fill_from(graphics::Buffer&) {}
+    void const* as_argb_8888() { return nullptr; }
+    geometry::Size size() const { return {}; }
+    geometry::Stride stride() const { return {}; }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_PIXEL_BUFFER_H_ */
 
=== added file 'include/test/mir_test_doubles/null_prompt_session.h'
--- include/test/mir_test_doubles/null_prompt_session.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_prompt_session.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2013-2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_PROMPT_SESSION_H_
+#define MIR_TEST_DOUBLES_NULL_PROMPT_SESSION_H_
+
+#include "mir/scene/prompt_session.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+class NullPromptSession : public scene::PromptSession
+{
+};
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_PROMPT_SESSION_H_ */
 
=== added file 'include/test/mir_test_doubles/null_prompt_session_manager.h'
--- include/test/mir_test_doubles/null_prompt_session_manager.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_prompt_session_manager.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright © 2014 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: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_NULL_PROMPT_SESSION_MANAGER_H_
+#define MIR_SCENE_NULL_PROMPT_SESSION_MANAGER_H_
+
+#include "mir/scene/prompt_session_manager.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class NullPromptSessionManager: public scene::PromptSessionManager
+{
+public:
+    std::shared_ptr<scene::PromptSession> start_prompt_session_for(std::shared_ptr<scene::Session> const&,
+                                                                   scene::PromptSessionCreationParameters const&) const
+    {
+        return std::shared_ptr<scene::PromptSession>();
+    }
+
+    void stop_prompt_session(std::shared_ptr<scene::PromptSession> const&) const
+    {
+    }
+
+    void add_prompt_provider(std::shared_ptr<scene::PromptSession> const&,
+                             std::shared_ptr<scene::Session> const&) const
+    {
+    }
+
+    void add_prompt_provider_by_pid(std::shared_ptr<scene::PromptSession> const&,
+                                    pid_t) const
+    {
+    }
+
+    void add_expected_session(std::shared_ptr<scene::Session> const&) const
+    {
+    }
+
+    void remove_session(std::shared_ptr<scene::Session> const&) const
+    {
+    }
+
+    std::shared_ptr<scene::Session> application_for(std::shared_ptr<scene::PromptSession> const&) const
+    {
+        return std::shared_ptr<scene::Session>();
+    }
+
+    std::shared_ptr<scene::Session> helper_for(std::shared_ptr<scene::PromptSession> const&) const
+    {
+        return std::shared_ptr<scene::Session>();
+    }
+
+    void for_each_provider_in(std::shared_ptr<scene::PromptSession> const&,
+                              std::function<void(std::shared_ptr<scene::Session> const&)> const&) const
+    {
+    }
+};
+
+}
+}
+}
+
+#endif // MIR_SCENE_NULL_PROMPT_SESSION_MANAGER_H_
 
=== modified file 'include/test/mir_test_doubles/null_virtual_terminal.h'
--- include/test/mir_test_doubles/null_virtual_terminal.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/null_virtual_terminal.h	2014-06-18 17:25:24 +0000
@@ -31,13 +31,15 @@
 class NullVirtualTerminal : public graphics::mesa::VirtualTerminal
 {
 public:
-    void set_graphics_mode() {}
+    void set_graphics_mode() override {}
 
     void register_switch_handlers(graphics::EventHandlerRegister&,
                                   std::function<bool()> const&,
-                                  std::function<bool()> const&)
+                                  std::function<bool()> const&) override
     {
     }
+
+    void restore() override {}
 };
 
 }
 
=== added file 'include/test/mir_test_doubles/platform_factory.h'
--- include/test/mir_test_doubles/platform_factory.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/platform_factory.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_PLATFORM_FACTORY_H_
+#define MIR_TEST_DOUBLES_PLATFORM_FACTORY_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+class Platform;
+namespace mesa { class Platform; }
+}
+namespace test
+{
+namespace doubles
+{
+
+std::shared_ptr<graphics::Platform> create_platform_with_null_dependencies();
+
+#ifndef ANDROID
+std::shared_ptr<graphics::mesa::Platform> create_mesa_platform_with_null_dependencies();
+#endif
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_PLATFORM_FACTORY_H_ */
 
=== modified file 'include/test/mir_test_doubles/stub_buffer.h'
--- include/test/mir_test_doubles/stub_buffer.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/stub_buffer.h	2014-06-18 17:25:24 +0000
@@ -21,6 +21,9 @@
 
 #ifdef ANDROID
 #include "mock_android_native_buffer.h"
+#else
+#include "src/platform/graphics/mesa/gbm_buffer.h"
+#include "mock_gbm.h"
 #endif
 
 #include "mir/graphics/buffer_basic.h"
@@ -59,6 +62,14 @@
           buf_pixel_format{properties.format},
           buf_stride{stride}
     {
+#ifndef ANDROID
+        auto buffer = std::make_shared<graphics::mesa::GBMNativeBuffer>();
+        int fake_bo{0}; 
+        buffer->bo = reinterpret_cast<gbm_bo*>(&fake_bo); //gbm_bo is opaque, so test code shouldn't dereference.
+        native_buffer = buffer;
+#else
+        native_buffer = std::make_shared<StubAndroidNativeBuffer>();
+#endif
     }
 
     virtual geometry::Size size() const { return buf_size; }
@@ -67,18 +78,12 @@
 
     virtual MirPixelFormat pixel_format() const { return buf_pixel_format; }
 
-    virtual std::shared_ptr<graphics::NativeBuffer> native_buffer_handle() const
-    {
-#ifndef ANDROID
-        return std::make_shared<graphics::NativeBuffer>();
-#else
-        return std::make_shared<StubAndroidNativeBuffer>();
-#endif
-    }
-    virtual void bind_to_texture() {}
-
-    virtual bool can_bypass() const override { return false; }
-
+    virtual std::shared_ptr<graphics::NativeBuffer> native_buffer_handle() const { return native_buffer; }
+    virtual void gl_bind_to_texture() override {}
+
+    virtual bool can_bypass() const override { return true; }
+
+    std::shared_ptr<graphics::NativeBuffer> native_buffer;
     geometry::Size const buf_size;
     MirPixelFormat const buf_pixel_format;
     geometry::Stride const buf_stride;
 
=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2014-06-18 17:25:24 +0000
@@ -36,10 +36,17 @@
     {
         stub_compositor_buffer = std::make_shared<StubBuffer>();
     }
-    void swap_client_buffers(graphics::Buffer*, std::function<void(graphics::Buffer* new_buffer)> complete) override
+
+    void acquire_client_buffer(
+        std::function<void(graphics::Buffer* buffer)> complete) override
     {
         complete(&stub_client_buffer);
     }
+
+    void release_client_buffer(graphics::Buffer*) override
+    {
+    }
+
     std::shared_ptr<graphics::Buffer> lock_compositor_buffer(void const*) override
     {
         return stub_compositor_buffer;
 
=== modified file 'include/test/mir_test_doubles/stub_display_builder.h'
--- include/test/mir_test_doubles/stub_display_builder.h	2014-05-28 07:43:51 +0000
+++ include/test/mir_test_doubles/stub_display_builder.h	2014-06-18 17:25:24 +0000
@@ -41,9 +41,9 @@
     void make_current() {}
     void release_current() {}
     void post_update() {}
-    bool can_bypass() const override { return false; }
     bool post_renderables_if_optimizable(graphics::RenderableList const&) { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
+    bool uses_alpha() const override { return false; };
     void configure(graphics::DisplayConfigurationOutput const&) {} 
     graphics::DisplayConfigurationOutput configuration() const
     {
 
=== added file 'include/test/mir_test_doubles/stub_frame_dropping_policy_factory.h'
--- include/test/mir_test_doubles/stub_frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_frame_dropping_policy_factory.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2014 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+
+#ifndef MIR_TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_
+#define MIR_TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_
+
+#include "mir/compositor/frame_dropping_policy_factory.h"
+#include "mir/compositor/frame_dropping_policy.h"
+
+namespace mc = mir::compositor;
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubFrameDroppingPolicy : public mc::FrameDroppingPolicy
+{
+public:
+    void swap_now_blocking()
+    {
+    }
+    void swap_unblocked()
+    {
+    }
+};
+
+class StubFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
+{
+public:
+    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(std::function<void(void)>) const override
+    {
+        return std::unique_ptr<mc::FrameDroppingPolicy>{new StubFrameDroppingPolicy};
+    }
+};
+
+}
+}
+}
+#endif // TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_
 
=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-05-22 16:50:25 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-06-18 17:25:24 +0000
@@ -22,6 +22,11 @@
 #include "mir_test_doubles/stub_buffer.h"
 #include <mir/graphics/renderable.h>
 #include <memory>
+#define GLM_FORCE_RADIANS
+#define GLM_PRECISION_MEDIUMP_FLOAT
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
 
 namespace mir
 {
@@ -33,20 +38,26 @@
 class StubRenderable : public graphics::Renderable
 {
 public:
+    StubRenderable(std::shared_ptr<graphics::Buffer> const& buffer, geometry::Rectangle const& rect)
+        : rect(rect),
+          stub_buffer(buffer)
+    {}
+
     StubRenderable(geometry::Rectangle const& rect)
-        : rect(rect)
+        : StubRenderable(make_stub_buffer(rect), rect)
     {}
+
     StubRenderable() :
-        StubRenderable({{},{}})
+        StubRenderable(make_stub_buffer({{},{}}), {{},{}})
     {}
+
     ID id() const override
     {
         return this;
     }
     std::shared_ptr<graphics::Buffer> buffer() const override
     {
-        graphics::BufferProperties prop{rect.size, mir_pixel_format_abgr_8888, graphics::BufferUsage::hardware};
-        return std::make_shared<StubBuffer>(prop);
+        return stub_buffer;
     }
     bool alpha_enabled() const
     {
@@ -79,10 +90,58 @@
     }
 
 private:
+    std::shared_ptr<graphics::Buffer> make_stub_buffer(geometry::Rectangle const& rect)
+    {
+        graphics::BufferProperties prop{
+            rect.size, mir_pixel_format_abgr_8888, graphics::BufferUsage::hardware};
+        return std::make_shared<StubBuffer>(prop);
+    }
+
     glm::mat4 trans;
     geometry::Rectangle const rect;
-};
-
+    std::shared_ptr<graphics::Buffer> const stub_buffer;
+};
+
+struct StubTransformedRenderable : public StubRenderable
+{
+    glm::mat4 transformation() const override
+    {
+        glm::mat4 transform(1.0);
+        glm::vec3 vec(1.0, 0.0, 0.0);
+        transform = glm::rotate(transform, 33.0f, vec);
+        return transform;
+    }
+};
+
+//hopefully the alpha representation gets condensed at some point
+struct StubShapedRenderable : public StubRenderable
+{
+    bool shaped() const override
+    {
+        return true;
+    }
+};
+
+struct StubTranslucentRenderable : public StubRenderable
+{
+    bool alpha_enabled() const override
+    {
+        return true;
+    }
+};
+
+struct PlaneAlphaRenderable : public StubRenderable
+{
+    bool alpha_enabled() const override
+    {
+        return true;
+    }
+    float alpha() const override
+    {
+        //approx 99% alpha 
+        return 1.0f - ( 3.0f / 1024.0f );
+    }
+};
 }
 }
 }
 
=== modified file 'include/test/mir_test_doubles/stub_scene_session.h'
--- include/test/mir_test_doubles/stub_scene_session.h	2014-05-22 11:31:21 +0000
+++ include/test/mir_test_doubles/stub_scene_session.h	2014-06-18 17:25:24 +0000
@@ -30,6 +30,8 @@
 
 struct StubSceneSession : public scene::Session
 {
+    StubSceneSession(pid_t pid = -1) : pid(pid) {}
+
     frontend::SurfaceId create_surface(scene::SurfaceCreationParameters const& /* params */) override
     {
         return frontend::SurfaceId{0};
@@ -45,9 +47,10 @@
     {
         return std::string();
     }
+
     pid_t process_id() const override
     {
-        return -1;
+        return pid;
     }
 
     void force_requests_to_complete() override
@@ -76,6 +79,16 @@
     void set_lifecycle_state(MirLifecycleState /*state*/)
     {
     }
+
+    void start_prompt_session() override
+    {
+    }
+
+    void stop_prompt_session() override
+    {
+    }
+
+    pid_t const pid;
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/stub_scene_surface.h'
--- include/test/mir_test_doubles/stub_scene_surface.h	2014-05-09 09:56:45 +0000
+++ include/test/mir_test_doubles/stub_scene_surface.h	2014-06-18 17:25:24 +0000
@@ -83,6 +83,10 @@
     void remove_observer(std::weak_ptr<scene::SurfaceObserver> const&) override {}
 
     void set_reception_mode(input::InputReceptionMode mode) override { input_mode = mode; }
+
+    void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& /* image */) {}
+    std::shared_ptr<graphics::CursorImage> cursor_image() { return {}; }
+
     MirPixelFormat pixel_format() const override { return mir_pixel_format_xrgb_8888; }
 
     void swap_buffers(graphics::Buffer*, std::function<void(graphics::Buffer*)>) override {}
 
=== modified file 'include/test/mir_test_doubles/stub_shell.h'
--- include/test/mir_test_doubles/stub_shell.h	2014-04-15 05:31:19 +0000
+++ include/test/mir_test_doubles/stub_shell.h	2014-06-18 17:25:24 +0000
@@ -49,6 +49,25 @@
     void handle_surface_created(std::shared_ptr<frontend::Session> const& /* session */) override
     {
     }
+    std::shared_ptr<frontend::PromptSession> start_prompt_session_for(std::shared_ptr<frontend::Session> const& /* session */,
+        scene::PromptSessionCreationParameters const& /* params */)
+    {
+        return std::shared_ptr<frontend::PromptSession>();
+    }
+    void add_prompt_provider_process_for(
+        std::shared_ptr<frontend::PromptSession> const&  /* prompt_session */,
+        pid_t /* process_id */)
+    {
+    }
+    void add_prompt_provider_for(
+        std::shared_ptr<frontend::PromptSession> const&  /* prompt_session */,
+        std::shared_ptr<frontend::Session> const& /* session */)
+    {
+    }
+    void stop_prompt_session(std::shared_ptr<frontend::PromptSession>  const& /* prompt_session */)
+    {
+    }
+
     std::shared_ptr<StubSession> const stub_session;
 };
 
 
=== modified file 'include/test/mir_test_doubles/stub_swapping_gl_context.h'
--- include/test/mir_test_doubles/stub_swapping_gl_context.h	2014-02-21 16:51:45 +0000
+++ include/test/mir_test_doubles/stub_swapping_gl_context.h	2014-06-18 17:25:24 +0000
@@ -20,6 +20,7 @@
 #define MIR_TEST_DOUBLES_STUB_SWAPPING_GL_CONTEXT_H_
 
 #include "src/platform/graphics/android/gl_context.h"
+#include "stub_buffer.h"
 
 namespace mir
 {
@@ -31,6 +32,10 @@
 struct StubSwappingGLContext : public graphics::android::SwappingGLContext
 {
     void swap_buffers() const {}
+    std::shared_ptr<graphics::Buffer> last_rendered_buffer() const
+    {
+        return std::make_shared<StubBuffer>();
+    }
 };
 
 }
 
=== modified file 'include/test/mir_test_framework/in_process_server.h'
--- include/test/mir_test_framework/in_process_server.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_framework/in_process_server.h	2014-06-18 17:25:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 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,
@@ -19,6 +19,8 @@
 #ifndef MIR_TEST_FRAMEWORK_IN_PROCESS_SERVER_H_
 #define MIR_TEST_FRAMEWORK_IN_PROCESS_SERVER_H_
 
+#include "mir_test_framework/server_runner.h"
+
 #include <gtest/gtest.h>
 
 #include <string>
@@ -34,29 +36,18 @@
 namespace mir_test_framework
 {
 /// Fixture for running Mir server in test process
-struct InProcessServer : testing::Test
+struct InProcessServer : testing::Test, private ServerRunner
 {
-    InProcessServer();
-    ~InProcessServer();
-
     /// Starts the server
     /// \warning don't forget to call this if you override SetUp()
-    void SetUp() override;
+    void SetUp() override { ServerRunner::start_server(); }
 
     /// Stops the server
     /// \warning don't forget to call this if you override TearDown()
-    void TearDown() override;
+    void TearDown() override { ServerRunner::stop_server(); }
 
     /// \return a connection string for a new client to connect to the server
-    std::string new_connection();
-
-private:
-    mir::DisplayServer* start_mir_server();
-    virtual mir::DefaultServerConfiguration& server_config() = 0;
-
-    char const* const old_env;
-    std::thread server_thread;
-    mir::DisplayServer* display_server = 0;
+    using ServerRunner::new_connection;
 };
 }
 
 
=== modified file 'include/test/mir_test_framework/input_testing_client_configuration.h'
--- include/test/mir_test_framework/input_testing_client_configuration.h	2014-05-26 14:41:49 +0000
+++ include/test/mir_test_framework/input_testing_client_configuration.h	2014-06-18 17:25:24 +0000
@@ -20,8 +20,7 @@
 #define MIR_TEST_FRAMEWORK_INPUT_TESTING_CLIENT_CONFIGURATION
 
 #include "mir_test_framework/testing_client_configuration.h"
-#include "mir_test_framework/cross_process_sync.h"
-#include "mir_test/wait_condition.h"
+#include "mir_test/barrier.h"
 
 #include <mir_toolkit/event.h>
 
@@ -29,6 +28,7 @@
 
 #include <string>
 
+namespace mir { namespace test  { class WaitCondition; } }
 namespace mir_test_framework
 {
 
@@ -38,7 +38,7 @@
 class InputTestingClientConfiguration : public TestingClientConfiguration
 {
 public:
-    InputTestingClientConfiguration(std::string const& client_name, CrossProcessSync const& input_cb_setup_fence);
+    InputTestingClientConfiguration(std::string const& client_name, mir::test::Barrier& input_cb_setup_fence);
     virtual ~InputTestingClientConfiguration() = default;
 
     void exec();
@@ -62,7 +62,7 @@
     std::string connect_string;
 private:
     std::string const client_name;
-    CrossProcessSync input_cb_setup_fence;
+    mir::test::Barrier& input_cb_setup_fence;
 };
 
 }
 
=== added file 'include/test/mir_test_framework/server_runner.h'
--- include/test/mir_test_framework/server_runner.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_framework/server_runner.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2014 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 MIR_TEST_FRAMEWORK_SERVER_RUNNER_H_
+#define MIR_TEST_FRAMEWORK_SERVER_RUNNER_H_
+
+#include <gtest/gtest.h>
+
+#include <string>
+#include <thread>
+
+namespace mir
+{
+class DisplayServer;
+class DefaultServerConfiguration;
+}
+
+namespace mir_test_framework
+{
+/// Utility for running Mir server in test process
+struct ServerRunner
+{
+    ServerRunner();
+    virtual ~ServerRunner();
+
+    /// Starts the server
+    void start_server();
+
+    /// Stops the server
+    void stop_server();
+
+    /// \return a connection string for a new client to connect to the server
+    std::string new_connection();
+
+private:
+    mir::DisplayServer* start_mir_server();
+    virtual mir::DefaultServerConfiguration& server_config() = 0;
+
+    char const* const old_env;
+    std::thread server_thread;
+    mir::DisplayServer* display_server = 0;
+};
+}
+
+#endif /* MIR_TEST_FRAMEWORK_SERVER_RUNNER_H_ */
 
=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2014-05-22 11:31:21 +0000
+++ src/client/CMakeLists.txt	2014-06-18 17:25:24 +0000
@@ -48,6 +48,9 @@
   mir_screencast.cpp
   mir_screencast_api.cpp
   mir_cursor_api.cpp
+  mir_prompt_session.cpp
+  mir_prompt_session_api.cpp
+  mir_event_distributor.cpp
 )
 
 add_library(
@@ -82,7 +85,7 @@
   mirclientlttngstatic
 
   ${MIR_COMMON_PLATFORM_LIBRARIES}
- 
+
   3rd_party
 )
 
 
=== modified file 'src/client/connection_configuration.h'
--- src/client/connection_configuration.h	2014-03-06 06:05:17 +0000
+++ src/client/connection_configuration.h	2014-06-18 17:25:24 +0000
@@ -47,6 +47,8 @@
 class ClientPlatformFactory;
 class DisplayConfiguration;
 class LifecycleControl;
+class EventSink;
+class EventHandlerRegister;
 
 class ConnectionConfiguration
 {
@@ -60,6 +62,8 @@
     virtual std::shared_ptr<input::receiver::InputPlatform> the_input_platform() = 0;
     virtual std::shared_ptr<DisplayConfiguration> the_display_configuration() = 0;
     virtual std::shared_ptr<LifecycleControl> the_lifecycle_control() = 0;
+    virtual std::shared_ptr<EventSink> the_event_sink() = 0;
+    virtual std::shared_ptr<EventHandlerRegister> the_event_handler_register() = 0;
 
 protected:
     ConnectionConfiguration() = default;
 
=== modified file 'src/client/connection_surface_map.h'
--- src/client/connection_surface_map.h	2014-03-06 06:05:17 +0000
+++ src/client/connection_surface_map.h	2014-06-18 17:25:24 +0000
@@ -33,6 +33,7 @@
 {
 public:
     ConnectionSurfaceMap();
+    ~ConnectionSurfaceMap() noexcept;
 
     void with_surface_do(int surface_id, std::function<void(MirSurface*)> exec) const override;
     void insert(int surface_id, MirSurface* surface);
 
=== modified file 'src/client/default_connection_configuration.cpp'
--- src/client/default_connection_configuration.cpp	2014-03-26 05:48:59 +0000
+++ src/client/default_connection_configuration.cpp	2014-06-18 17:25:24 +0000
@@ -32,6 +32,7 @@
 #include "lifecycle_control.h"
 #include "mir/shared_library.h"
 #include "client_platform_factory.h"
+#include "mir_event_distributor.h"
 
 namespace mcl = mir::client;
 
@@ -81,7 +82,7 @@
         [this]
         {
             return mcl::rpc::make_rpc_channel(
-                the_socket_file(), the_surface_map(), the_display_configuration(), the_rpc_report(), the_lifecycle_control());
+                the_socket_file(), the_surface_map(), the_display_configuration(), the_rpc_report(), the_lifecycle_control(), the_event_sink());
         });
 }
 
@@ -182,3 +183,21 @@
             return std::make_shared<mcl::LifecycleControl>();
         });
 }
+
+std::shared_ptr<mcl::EventSink> mcl::DefaultConnectionConfiguration::the_event_sink()
+{
+    return event_distributor(
+        []
+        {
+            return std::make_shared<MirEventDistributor>();
+        });
+}
+
+std::shared_ptr<mcl::EventHandlerRegister> mcl::DefaultConnectionConfiguration::the_event_handler_register()
+{
+    return event_distributor(
+        []
+        {
+            return std::make_shared<MirEventDistributor>();
+        });
+}
 
=== modified file 'src/client/default_connection_configuration.h'
--- src/client/default_connection_configuration.h	2014-03-06 06:05:17 +0000
+++ src/client/default_connection_configuration.h	2014-06-18 17:25:24 +0000
@@ -36,6 +36,7 @@
 }
 namespace client
 {
+class EventDistributor;
 
 namespace rpc
 {
@@ -54,6 +55,8 @@
     std::shared_ptr<input::receiver::InputPlatform> the_input_platform();
     std::shared_ptr<DisplayConfiguration> the_display_configuration();
     std::shared_ptr<LifecycleControl> the_lifecycle_control();
+    std::shared_ptr<EventSink> the_event_sink();
+    std::shared_ptr<EventHandlerRegister> the_event_handler_register();
 
     virtual std::string the_socket_file();
     virtual std::shared_ptr<rpc::RpcReport> the_rpc_report();
@@ -67,6 +70,7 @@
     CachedPtr<ConnectionSurfaceMap> surface_map;
     CachedPtr<DisplayConfiguration> display_configuration;
     CachedPtr<LifecycleControl> lifecycle_control;
+    CachedPtr<EventDistributor> event_distributor;
 
     CachedPtr<rpc::RpcReport> rpc_report;
     CachedPtr<input::receiver::InputReceiverReport> input_receiver_report;
 
=== added file 'src/client/event_distributor.h'
--- src/client/event_distributor.h	1970-01-01 00:00:00 +0000
+++ src/client/event_distributor.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_EVENT_DISTRIBUTOR_H_
+#define MIR_CLIENT_EVENT_DISTRIBUTOR_H_
+
+#include "event_sink.h"
+#include "event_handler_register.h"
+
+namespace mir
+{
+namespace client
+{
+
+class EventDistributor : public EventHandlerRegister, public EventSink
+{
+};
+
+} // namespace client
+} // namespace mir
+
+#endif // MIR_CLIENT_EVENT_DISTRIBUTOR_H_
 
=== added file 'src/client/event_handler_register.h'
--- src/client/event_handler_register.h	1970-01-01 00:00:00 +0000
+++ src/client/event_handler_register.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_EVENT_HANDLER_REGISTER_H_
+#define MIR_CLIENT_EVENT_HANDLER_REGISTER_H_
+
+#include "mir_toolkit/event.h"
+
+#include <functional>
+
+namespace mir
+{
+namespace client
+{
+
+class EventHandlerRegister
+{
+public:
+    virtual ~EventHandlerRegister() = default;
+
+    virtual int register_event_handler(std::function<void(MirEvent const&)> const&) = 0;
+    virtual void unregister_event_handler(int id) = 0;
+
+protected:
+    EventHandlerRegister() = default;
+    EventHandlerRegister(EventHandlerRegister const&) = delete;
+    EventHandlerRegister& operator=(EventHandlerRegister const&) = delete;
+};
+} // namespace client
+} // namespace mir
+
+#endif // MIR_CLIENT_EVENT_HANDLER_REGISTER_H_
 
=== added file 'src/client/event_sink.h'
--- src/client/event_sink.h	1970-01-01 00:00:00 +0000
+++ src/client/event_sink.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_EVENT_SINK_H_
+#define MIR_CLIENT_EVENT_SINK_H_
+
+#include "mir_toolkit/event.h"
+
+namespace mir
+{
+namespace client
+{
+
+class EventSink
+{
+public:
+    virtual ~EventSink() = default;
+
+    virtual void handle_event(MirEvent const& e) = 0;
+
+protected:
+    EventSink() = default;
+    EventSink(EventSink const&) = delete;
+    EventSink& operator=(EventSink const&) = delete;
+};
+} // namespace client
+} // namespace mir
+
+#endif // MIR_CLIENT_EVENT_SINK_H_
 
=== modified file 'src/client/logging/input_receiver_report.cpp'
--- src/client/logging/input_receiver_report.cpp	2014-03-06 06:05:17 +0000
+++ src/client/logging/input_receiver_report.cpp	2014-06-18 17:25:24 +0000
@@ -91,6 +91,7 @@
         ss << "    orientation: " << ev.pointer_coordinates[i].orientation << std::endl;
         ss << "    vscroll: " << ev.pointer_coordinates[i].vscroll << std::endl;
         ss << "    hscroll: " << ev.pointer_coordinates[i].hscroll << std::endl;
+        ss << "    tool_type: " << ev.pointer_coordinates[i].tool_type << std::endl;
         ss << "  }" << std::endl;
     }
     ss << "}";
 
=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2014-05-22 11:31:21 +0000
+++ src/client/mir_connection.cpp	2014-06-18 17:25:24 +0000
@@ -18,6 +18,7 @@
 
 #include "mir_connection.h"
 #include "mir_surface.h"
+#include "mir_prompt_session.h"
 #include "client_platform.h"
 #include "client_platform_factory.h"
 #include "rpc/mir_basic_rpc_channel.h"
@@ -82,7 +83,8 @@
         input_platform(conf.the_input_platform()),
         display_configuration(conf.the_display_configuration()),
         lifecycle_control(conf.the_lifecycle_control()),
-        surface_map(conf.the_surface_map())
+        surface_map(conf.the_surface_map()),
+        event_handler_register(conf.the_event_handler_register())
 {
     connect_result.set_error("connect not called");
     {
@@ -186,6 +188,7 @@
         release_wait_handles.push_back(new_wait_handle);
     }
 
+    new_wait_handle->expect_result();
     server.release_surface(0, &message, &void_response,
                            gp::NewCallback(this, &MirConnection::released, surf_release));
 
@@ -193,6 +196,11 @@
     return new_wait_handle;
 }
 
+MirPromptSession* MirConnection::create_prompt_session()
+{
+    return new MirPromptSession(display_server(), event_handler_register);
+}
+
 namespace
 {
 void default_lifecycle_event_handler(MirLifecycleState transition)
@@ -272,6 +280,7 @@
 
 MirWaitHandle* MirConnection::disconnect()
 {
+    disconnect_wait_handle.expect_result();
     server.disconnect(0, &ignored, &ignored,
                       google::protobuf::NewCallback(this, &MirConnection::done_disconnect));
 
@@ -294,6 +303,7 @@
     mir::protobuf::DRMMagic request;
     request.set_magic(magic);
 
+    drm_auth_magic_wait_handle.expect_result();
     server.drm_auth_magic(
         0,
         &request,
@@ -304,40 +314,6 @@
     return &drm_auth_magic_wait_handle;
 }
 
-MirWaitHandle* MirConnection::new_fds_for_trusted_clients(
-    unsigned int no_of_fds,
-    mir_client_fd_callback callback,
-    void * context)
-{
-    mir::protobuf::SocketFDRequest request;
-    request.set_number(no_of_fds);
-
-    server.new_fds_for_trusted_clients(
-        nullptr,
-        &request,
-        &socket_fd_response,
-        google::protobuf::NewCallback(this, &MirConnection::done_fds_for_trusted_clients,
-                                              callback, context));
-
-    return &fds_for_trusted_clients_wait_handle;
-}
-
-void MirConnection::done_fds_for_trusted_clients(
-    mir_client_fd_callback callback,
-    void* context)
-{
-    auto const size = socket_fd_response.fd_size();
-
-    std::vector<int> fds;
-    fds.reserve(size);
-
-    for (auto i = 0; i != size; ++i)
-        fds.push_back(socket_fd_response.fd(i));
-
-    callback(this, size, fds.data(), context);
-    fds_for_trusted_clients_wait_handle.result_received();
-}
-
 bool MirConnection::is_valid(MirConnection *connection)
 {
     {
@@ -500,6 +476,7 @@
         }
     }
 
+    configure_display_wait_handle.expect_result();
     server.configure_display(0, &request, &display_configuration_response,
         google::protobuf::NewCallback(this, &MirConnection::done_display_configure));
 
@@ -522,6 +499,6 @@
 }
 
 mir::protobuf::DisplayServer& MirConnection::display_server()
-{ 
+{
     return server;
 }
 
=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2014-05-22 11:31:21 +0000
+++ src/client/mir_connection.h	2014-06-18 17:25:24 +0000
@@ -45,6 +45,7 @@
 class ConnectionSurfaceMap;
 class DisplayConfiguration;
 class LifecycleControl;
+class EventHandlerRegister;
 
 namespace rpc
 {
@@ -86,6 +87,8 @@
             mir_surface_callback callback,
             void *context);
 
+    MirPromptSession* create_prompt_session();
+
     char const * get_error_message();
 
     MirWaitHandle* connect(
@@ -123,11 +126,6 @@
 
     bool set_extra_platform_data(std::vector<int> const& extra_platform_data);
 
-    MirWaitHandle* new_fds_for_trusted_clients(
-        unsigned int no_of_fds,
-        mir_client_fd_callback callback,
-        void * context);
-
     std::shared_ptr<google::protobuf::RpcChannel> rpc_channel() const
     {
         return channel;
@@ -147,7 +145,6 @@
     mir::protobuf::ConnectParameters connect_parameters;
     mir::protobuf::DRMAuthMagicStatus drm_auth_magic_status;
     mir::protobuf::DisplayConfiguration display_configuration_response;
-    mir::protobuf::SocketFD socket_fd_response;
 
     std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
     std::shared_ptr<mir::client::ClientPlatform> platform;
@@ -161,7 +158,6 @@
     MirWaitHandle disconnect_wait_handle;
     MirWaitHandle drm_auth_magic_wait_handle;
     MirWaitHandle configure_display_wait_handle;
-    MirWaitHandle fds_for_trusted_clients_wait_handle;
 
     std::mutex release_wait_handle_guard;
     std::vector<MirWaitHandle*> release_wait_handles;
@@ -172,6 +168,8 @@
 
     std::shared_ptr<mir::client::ConnectionSurfaceMap> const surface_map;
 
+    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
+
     std::vector<int> extra_platform_data;
 
     struct SurfaceRelease;
@@ -181,7 +179,6 @@
     void connected(mir_connected_callback callback, void * context);
     void released(SurfaceRelease );
     void done_drm_auth_magic(mir_drm_auth_magic_callback callback, void* context);
-    void done_fds_for_trusted_clients(mir_client_fd_callback callback, void* context);
     bool validate_user_display_config(MirDisplayConfiguration* config);
 };
 
 
=== modified file 'src/client/mir_connection_api.cpp'
--- src/client/mir_connection_api.cpp	2014-05-22 11:31:21 +0000
+++ src/client/mir_connection_api.cpp	2014-06-18 17:25:24 +0000
@@ -272,24 +272,6 @@
     }
 }
 
-MirWaitHandle* mir_connection_new_fds_for_trusted_clients(
-    MirConnection* connection,
-    unsigned int no_of_fds,
-    mir_client_fd_callback callback,
-    void * context)
-{
-    try
-    {
-        return connection ?
-            connection->new_fds_for_trusted_clients(no_of_fds, callback, context) :
-            nullptr;
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
 MirEGLNativeDisplayType mir_connection_get_egl_native_display(
     MirConnection* connection)
 {
 
=== added file 'src/client/mir_event_distributor.cpp'
--- src/client/mir_event_distributor.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_event_distributor.cpp	2014-06-18 17:25:24 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include "mir_event_distributor.h"
+
+MirEventDistributor::MirEventDistributor() :
+    next_fn_id{0}
+{
+}
+
+int MirEventDistributor::register_event_handler(std::function<void(MirEvent const&)> const& fn)
+{
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    int id = ++next_fn_id;
+    event_handlers[id] = fn;
+    return id;
+}
+
+void MirEventDistributor::unregister_event_handler(int id)
+{
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    event_handlers.erase(id);
+}
+
+void MirEventDistributor::handle_event(MirEvent const& event)
+{
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    auto const event_handlers_copy(event_handlers);
+
+    for (auto const& handler : event_handlers_copy)
+    {
+        // Ensure handler wasn't unregistered since making copy
+        if (event_handlers.find(handler.first) != event_handlers.end())
+        {
+            handler.second(event);
+        }
+    }
+}
 
=== added file 'src/client/mir_event_distributor.h'
--- src/client/mir_event_distributor.h	1970-01-01 00:00:00 +0000
+++ src/client/mir_event_distributor.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_EVENT_DISTRIBUTOR_H
+
+#include "event_distributor.h"
+
+#include <mutex>
+#include <map>
+
+class MirEventDistributor : public mir::client::EventDistributor
+{
+public:
+    MirEventDistributor();
+    ~MirEventDistributor() = default;
+
+    int register_event_handler(std::function<void(MirEvent const&)> const&) override;
+    void unregister_event_handler(int id) override;
+
+    void handle_event(MirEvent const& event) override;
+
+private:
+    mutable std::recursive_mutex mutex;
+    std::map<int, std::function<void(MirEvent const&)>> event_handlers;
+    int next_fn_id;
+};
+
+#endif /* MIR_EVENT_DISTRIBUTOR_H */
 
=== added file 'src/client/mir_prompt_session.cpp'
--- src/client/mir_prompt_session.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_prompt_session.cpp	2014-06-18 17:25:24 +0000
@@ -0,0 +1,203 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include "mir_prompt_session.h"
+#include "event_handler_register.h"
+
+namespace mp = mir::protobuf;
+namespace mcl = mir::client;
+
+MirPromptSession::MirPromptSession(
+    mp::DisplayServer& server,
+    std::shared_ptr<mcl::EventHandlerRegister> const& event_handler_register) :
+    server(server),
+    event_handler_register(event_handler_register),
+    event_handler_register_id{event_handler_register->register_event_handler(
+        [this](MirEvent const& event)
+        {
+            if (event.type == mir_event_type_prompt_session_state_change)
+                set_state(event.prompt_session.new_state);
+        })},
+    state(mir_prompt_session_state_stopped),
+    handle_prompt_session_state_change{[](MirPromptSessionState){}}
+{
+}
+
+MirPromptSession::~MirPromptSession()
+{
+    set_state(mir_prompt_session_state_stopped);
+}
+
+void MirPromptSession::set_state(MirPromptSessionState new_state)
+{
+    std::lock_guard<decltype(event_handler_mutex)> lock(event_handler_mutex);
+
+    if (new_state != state)
+    {
+        handle_prompt_session_state_change(new_state);
+
+        if (new_state == mir_prompt_session_state_stopped)
+        {
+            event_handler_register->unregister_event_handler(event_handler_register_id);
+        }
+
+        state = new_state;
+    }
+}
+
+MirWaitHandle* MirPromptSession::start(pid_t application_pid, mir_prompt_session_callback callback, void* context)
+{
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        parameters.set_application_pid(application_pid);
+    }
+
+    start_wait_handle.expect_result();
+    server.start_prompt_session(
+        0,
+        &parameters,
+        &session,
+        google::protobuf::NewCallback(this, &MirPromptSession::done_start,
+                                      callback, context));
+
+    return &start_wait_handle;
+}
+
+MirWaitHandle* MirPromptSession::stop(mir_prompt_session_callback callback, void* context)
+{
+    stop_wait_handle.expect_result();
+
+    server.stop_prompt_session(
+        0,
+        &protobuf_void,
+        &protobuf_void,
+        google::protobuf::NewCallback(this, &MirPromptSession::done_stop,
+                                      callback, context));
+
+    return &stop_wait_handle;
+}
+
+MirWaitHandle* MirPromptSession::add_prompt_provider(pid_t provider_pid,
+    mir_prompt_session_add_prompt_provider_callback callback,
+    void* context)
+{
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        prompt_provider.set_pid(provider_pid);
+    }
+
+    add_result_wait_handle.expect_result();
+    server.add_prompt_provider(
+        0,
+        &prompt_provider,
+        &add_result,
+        google::protobuf::NewCallback(this, &MirPromptSession::done_add_prompt_provider,
+                                      callback, context));
+
+    return &add_result_wait_handle;
+}
+
+void MirPromptSession::register_prompt_session_state_change_callback(
+    mir_prompt_session_state_change_callback callback,
+    void* context)
+{
+    std::lock_guard<decltype(event_handler_mutex)> lock(event_handler_mutex);
+
+    handle_prompt_session_state_change =
+        [this, callback, context](MirPromptSessionState new_state)
+        {
+            callback(this, new_state, context);
+        };
+}
+
+void MirPromptSession::done_start(mir_prompt_session_callback callback, void* context)
+{
+    {
+        std::lock_guard<decltype(session_mutex)> lock(session_mutex);
+
+        state = session.has_error() ? mir_prompt_session_state_stopped : mir_prompt_session_state_started;
+    }
+
+    callback(this, context);
+    start_wait_handle.result_received();
+}
+
+void MirPromptSession::done_stop(mir_prompt_session_callback callback, void* context)
+{
+    set_state(mir_prompt_session_state_stopped);
+
+    callback(this, context);
+    stop_wait_handle.result_received();
+}
+
+void MirPromptSession::done_add_prompt_provider(mir_prompt_session_add_prompt_provider_callback callback, void* context)
+{
+    MirBool added = mir_true;
+    if (add_result.has_error())
+    {
+        added = mir_false;
+    }
+    callback(this, added, context);
+    add_result_wait_handle.result_received();
+}
+
+char const* MirPromptSession::get_error_message()
+{
+    std::lock_guard<decltype(session_mutex)> lock(session_mutex);
+
+    if (!session.has_error())
+        session.set_error(std::string{});
+
+    return session.error().c_str();
+}
+
+MirWaitHandle* MirPromptSession::new_fds_for_prompt_providers(
+    unsigned int no_of_fds,
+    mir_client_fd_callback callback,
+    void * context)
+{
+    mir::protobuf::SocketFDRequest request;
+    request.set_number(no_of_fds);
+
+    fds_for_prompt_providers_wait_handle.expect_result();
+
+    server.new_fds_for_prompt_providers(
+        nullptr,
+        &request,
+        &socket_fd_response,
+        google::protobuf::NewCallback(this, &MirPromptSession::done_fds_for_prompt_providers,
+                                              callback, context));
+
+    return &fds_for_prompt_providers_wait_handle;
+}
+
+void MirPromptSession::done_fds_for_prompt_providers(
+    mir_client_fd_callback callback,
+    void* context)
+{
+    auto const size = socket_fd_response.fd_size();
+
+    std::vector<int> fds;
+    fds.reserve(size);
+
+    for (auto i = 0; i != size; ++i)
+        fds.push_back(socket_fd_response.fd(i));
+
+    callback(this, size, fds.data(), context);
+    fds_for_prompt_providers_wait_handle.result_received();
+}
 
=== added file 'src/client/mir_prompt_session.h'
--- src/client/mir_prompt_session.h	1970-01-01 00:00:00 +0000
+++ src/client/mir_prompt_session.h	2014-06-18 17:25:24 +0000
@@ -0,0 +1,94 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_MIR_PROMPT_SESSION_H_
+#define MIR_CLIENT_MIR_PROMPT_SESSION_H_
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include "mir_protobuf.pb.h"
+#include "mir_wait_handle.h"
+
+#include <mutex>
+#include <memory>
+#include <atomic>
+
+namespace mir
+{
+/// The client-side library implementation namespace
+namespace client
+{
+class EventHandlerRegister;
+}
+}
+
+struct MirPromptSession
+{
+public:
+    MirPromptSession(mir::protobuf::DisplayServer& server,
+                     std::shared_ptr<mir::client::EventHandlerRegister> const& event_handler_register);
+
+    ~MirPromptSession();
+
+    MirWaitHandle* start(pid_t application_pid, mir_prompt_session_callback callback, void* context);
+    MirWaitHandle* stop(mir_prompt_session_callback callback, void* context);
+    MirWaitHandle* add_prompt_provider(pid_t provider_pid, mir_prompt_session_add_prompt_provider_callback callback, void* context);
+
+    MirWaitHandle* new_fds_for_prompt_providers(
+        unsigned int no_of_fds,
+        mir_client_fd_callback callback,
+        void * context);
+
+    void register_prompt_session_state_change_callback(mir_prompt_session_state_change_callback callback, void* context);
+
+    char const* get_error_message();
+
+private:
+    std::mutex mutable mutex; // Protects parameters, wait_handles & results
+    mir::protobuf::DisplayServer& server;
+    mir::protobuf::PromptProvider prompt_provider;
+    mir::protobuf::PromptSessionParameters parameters;
+    mir::protobuf::Void add_result;
+    mir::protobuf::Void protobuf_void;
+    mir::protobuf::SocketFD socket_fd_response;
+    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
+    int const event_handler_register_id;
+
+    MirWaitHandle start_wait_handle;
+    MirWaitHandle stop_wait_handle;
+    MirWaitHandle add_result_wait_handle;
+    MirWaitHandle fds_for_prompt_providers_wait_handle;
+    std::atomic<MirPromptSessionState> state;
+
+    std::mutex mutable session_mutex; // Protects session
+    mir::protobuf::Void session;
+
+    std::mutex mutable event_handler_mutex; // Need another mutex for callback access to members
+    std::function<void(MirPromptSessionState)> handle_prompt_session_state_change;
+
+    void set_state(MirPromptSessionState new_state);
+    void done_start(mir_prompt_session_callback callback, void* context);
+    void done_stop(mir_prompt_session_callback callback, void* context);
+    void done_add_prompt_provider(mir_prompt_session_add_prompt_provider_callback callback, void* context);
+    void done_fds_for_prompt_providers(mir_client_fd_callback callback, void* context);
+    MirPromptSession(MirPromptSession const&) = delete;
+    MirPromptSession& operator=(MirPromptSession const&) = delete;
+};
+
+#endif /* MIR_CLIENT_MIR_PROMPT_SESSION_H_ */
+
 
=== added file 'src/client/mir_prompt_session_api.cpp'
--- src/client/mir_prompt_session_api.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_prompt_session_api.cpp	2014-06-18 17:25:24 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+
+#include "mir_toolkit/mir_prompt_session.h"
+#include "mir_prompt_session.h"
+#include "mir_connection.h"
+
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+
+namespace
+{
+void null_callback(MirPromptSession*, void*) {}
+
+void add_prompt_provider_callback(
+    MirPromptSession*,
+    MirBool added,
+    void* context)
+{
+    if (context)
+        *(MirBool*)context = added;
+}
+
+}
+
+MirPromptSession *mir_connection_create_prompt_session_sync(
+    MirConnection* connection,
+    pid_t application_pid,
+    mir_prompt_session_state_change_callback state_change_callback,
+    void* context)
+{
+    try
+    {
+        auto prompt_session = connection->create_prompt_session();
+        if (state_change_callback)
+            prompt_session->register_prompt_session_state_change_callback(state_change_callback, context);
+
+        mir_wait_for(prompt_session->start(application_pid,
+                     null_callback,
+                     nullptr));
+        return prompt_session;
+    }
+    catch (std::exception const&)
+    {
+        // TODO callback with an error
+        return nullptr;
+    }
+}
+
+MirWaitHandle *mir_prompt_session_add_prompt_provider(
+    MirPromptSession *prompt_session,
+    pid_t provider_pid,
+    mir_prompt_session_add_prompt_provider_callback callback,
+    void* context)
+{
+    try
+    {
+        return prompt_session->add_prompt_provider(provider_pid, callback, context);
+    }
+    catch (std::exception const&)
+    {
+        // TODO callback with an error
+        return nullptr;
+    }
+}
+
+MirBool mir_prompt_session_add_prompt_provider_sync(
+    MirPromptSession *prompt_session,
+    pid_t provider_pid)
+{
+    MirBool result;
+    mir_wait_for(mir_prompt_session_add_prompt_provider(prompt_session,
+        provider_pid,
+        add_prompt_provider_callback,
+        &result));
+    return result;
+}
+
+MirWaitHandle* mir_prompt_session_new_fds_for_prompt_providers(
+    MirPromptSession *prompt_session,
+    unsigned int no_of_fds,
+    mir_client_fd_callback callback,
+    void * context)
+{
+    try
+    {
+        return prompt_session ?
+            prompt_session->new_fds_for_prompt_providers(no_of_fds, callback, context) :
+            nullptr;
+    }
+    catch (std::exception const&)
+    {
+        return nullptr;
+    }
+}
+
+void mir_prompt_session_release_sync(
+    MirPromptSession *prompt_session)
+{
+    mir_wait_for(prompt_session->stop(&null_callback, nullptr));
+    delete prompt_session;
+}
 
=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2014-03-11 16:19:27 +0000
+++ src/client/mir_screencast.cpp	2014-06-18 17:25:24 +0000
@@ -102,6 +102,7 @@
     parameters.set_height(output_size.height.as_uint32_t());
     parameters.set_pixel_format(pixel_format);
 
+    create_screencast_wait_handle.expect_result();
     server.create_screencast(
         nullptr,
         &parameters,
@@ -143,6 +144,7 @@
     mir::protobuf::ScreencastId screencast_id;
     screencast_id.set_value(protobuf_screencast.screencast_id().value());
 
+    release_wait_handle.expect_result();
     server.release_screencast(
         nullptr,
         &screencast_id,
@@ -159,6 +161,7 @@
     mir::protobuf::ScreencastId screencast_id;
     screencast_id.set_value(protobuf_screencast.screencast_id().value());
 
+    next_buffer_wait_handle.expect_result();
     server.screencast_buffer(
         nullptr,
         &screencast_id,
 
=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2014-05-23 07:25:58 +0000
+++ src/client/mir_surface.cpp	2014-06-18 17:25:24 +0000
@@ -62,6 +62,7 @@
     message.set_buffer_usage(params.buffer_usage);
     message.set_output_id(params.output_id);
 
+    create_wait_handle.expect_result();
     server.create_surface(0, &message, &surface, gp::NewCallback(this, &MirSurface::created, callback, context));
 
     for (int i = 0; i < mir_surface_attribs; i++)
@@ -76,6 +77,11 @@
 
 MirSurface::~MirSurface()
 {
+    {
+        std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
+        valid_surfaces.erase(this);
+    }
+
     std::lock_guard<decltype(mutex)> lock(mutex);
 
     if (input_thread)
@@ -158,6 +164,7 @@
     auto const mutable_buffer = surface.mutable_buffer();
     lock.unlock();
 
+    next_buffer_wait_handle.expect_result();
     server.next_buffer(
         0,
         id,
@@ -243,8 +250,10 @@
         mir_surface_callback callback,
         void * context)
 {
-    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
-    valid_surfaces.erase(this);
+    {
+        std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
+        valid_surfaces.erase(this);
+    }
 
     return connection->release_surface(this, callback, context);
 }
@@ -323,7 +332,7 @@
     
     configure_cursor_wait_handle.expect_result();
     server.configure_cursor(0, &setting, &void_response,
-        google::protobuf::NewCallback(this, &MirSurface::on_configured));
+        google::protobuf::NewCallback(this, &MirSurface::on_cursor_configured));
     
     return &configure_cursor_wait_handle;
 }
@@ -375,6 +384,12 @@
     }
 }
 
+void MirSurface::on_cursor_configured()
+{
+    configure_cursor_wait_handle.result_received();
+}
+
+
 int MirSurface::attrib(MirSurfaceAttrib at) const
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2014-05-23 07:25:58 +0000
+++ src/client/mir_surface.h	2014-06-18 17:25:24 +0000
@@ -102,6 +102,7 @@
     mutable std::mutex mutex; // Protects all members of *this
 
     void on_configured();
+    void on_cursor_configured();
     void process_incoming_buffer();
     void populate(MirBufferPackage& buffer_package);
     void created(mir_surface_callback callback, void * context);
 
=== modified file 'src/client/mir_wait_handle.cpp'
--- src/client/mir_wait_handle.cpp	2013-10-03 03:44:08 +0000
+++ src/client/mir_wait_handle.cpp	2014-06-18 17:25:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3,
@@ -33,14 +33,14 @@
 
 void MirWaitHandle::expect_result()
 {
-    std::unique_lock<std::mutex> lock(guard);
+    std::lock_guard<std::mutex> lock(guard);
 
     expecting++;
 }
 
 void MirWaitHandle::result_received()
 {
-    std::unique_lock<std::mutex> lock(guard);
+    std::lock_guard<std::mutex> lock(guard);
 
     received++;
     wait_condition.notify_all();
@@ -50,8 +50,7 @@
 {
     std::unique_lock<std::mutex> lock(guard);
 
-    while ((!expecting && !received) || (received < expecting))
-        wait_condition.wait(lock);
+    wait_condition.wait(lock, [&]{ return received == expecting; });
 
     received = 0;
     expecting = 0;
@@ -59,14 +58,9 @@
 
 void MirWaitHandle::wait_for_pending(std::chrono::milliseconds limit)
 {
-    using std::chrono::steady_clock;
-
     std::unique_lock<std::mutex> lock(guard);
 
-    auto time_limit = steady_clock::now() + limit;
-
-    while (received < expecting && steady_clock::now() < time_limit)
-        wait_condition.wait_until(lock, time_limit);
+    wait_condition.wait_for(lock, limit, [&]{ return received == expecting; });
 }
 
 
@@ -74,11 +68,9 @@
 {
     std::unique_lock<std::mutex> lock(guard);
 
-    while (received == 0)
-        wait_condition.wait(lock);
+    wait_condition.wait(lock, [&]{ return received != 0; });
 
-    received--;
-    if (expecting > 0)
-        expecting--;
+    --received;
+    --expecting;
 }
 
 
=== modified file 'src/client/rpc/make_rpc_channel.h'
--- src/client/rpc/make_rpc_channel.h	2014-03-06 06:05:17 +0000
+++ src/client/rpc/make_rpc_channel.h	2014-06-18 17:25:24 +0000
@@ -29,6 +29,7 @@
 class SurfaceMap;
 class DisplayConfiguration;
 class LifecycleControl;
+class EventSink;
 
 namespace rpc
 {
@@ -39,7 +40,8 @@
                  std::shared_ptr<SurfaceMap> const& map,
                  std::shared_ptr<DisplayConfiguration> const& disp_conf,
                  std::shared_ptr<RpcReport> const& rpc_report,
-                 std::shared_ptr<LifecycleControl> const& lifecycle_control);
+                 std::shared_ptr<LifecycleControl> const& lifecycle_control,
+                 std::shared_ptr<EventSink> const& event_distributor);
 }
 }
 }
 
=== modified file 'src/client/rpc/make_socket_rpc_channel.cpp'
--- src/client/rpc/make_socket_rpc_channel.cpp	2014-03-06 06:05:17 +0000
+++ src/client/rpc/make_socket_rpc_channel.cpp	2014-06-18 17:25:24 +0000
@@ -44,13 +44,14 @@
                        std::shared_ptr<mcl::SurfaceMap> const& map,
                        std::shared_ptr<mcl::DisplayConfiguration> const& disp_conf,
                        std::shared_ptr<RpcReport> const& rpc_report,
-                       std::shared_ptr<mcl::LifecycleControl> const& lifecycle_control)
+                       std::shared_ptr<mcl::LifecycleControl> const& lifecycle_control,
+                       std::shared_ptr<mcl::EventSink> const& event_sink)
 {
     if (fd_prefix.is_start_of(name))
     {
         auto const fd = atoi(name.c_str()+fd_prefix.size);
-        return std::make_shared<MirSocketRpcChannel>(fd, map, disp_conf, rpc_report, lifecycle_control);
+        return std::make_shared<MirSocketRpcChannel>(fd, map, disp_conf, rpc_report, lifecycle_control, event_sink);
     }
 
-    return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report, lifecycle_control);
+    return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report, lifecycle_control, event_sink);
 }
 
=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2014-05-22 12:41:12 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2014-06-18 17:25:24 +0000
@@ -24,6 +24,7 @@
 #include "../mir_surface.h"
 #include "../display_configuration.h"
 #include "../lifecycle_control.h"
+#include "../event_sink.h"
 #include "mir/variable_length_array.h"
 
 #include "mir_protobuf.pb.h"  // For Buffer frig
@@ -50,7 +51,8 @@
     std::shared_ptr<mcl::SurfaceMap> const& surface_map,
     std::shared_ptr<DisplayConfiguration> const& disp_config,
     std::shared_ptr<RpcReport> const& rpc_report,
-    std::shared_ptr<LifecycleControl> const& lifecycle_control) :
+    std::shared_ptr<LifecycleControl> const& lifecycle_control,
+    std::shared_ptr<EventSink> const& event_sink) :
     rpc_report(rpc_report),
     pending_calls(rpc_report),
     work(io_service),
@@ -58,6 +60,7 @@
     surface_map(surface_map),
     display_configuration(disp_config),
     lifecycle_control(lifecycle_control),
+    event_sink(event_sink),
     disconnected(false)
 {
     socket.connect(endpoint);
@@ -69,7 +72,8 @@
     std::shared_ptr<mcl::SurfaceMap> const& surface_map,
     std::shared_ptr<DisplayConfiguration> const& disp_config,
     std::shared_ptr<RpcReport> const& rpc_report,
-    std::shared_ptr<LifecycleControl> const& lifecycle_control) :
+    std::shared_ptr<LifecycleControl> const& lifecycle_control,
+    std::shared_ptr<EventSink> const& event_sink) :
     rpc_report(rpc_report),
     pending_calls(rpc_report),
     work(io_service),
@@ -77,6 +81,7 @@
     surface_map(surface_map),
     display_configuration(disp_config),
     lifecycle_control(lifecycle_control),
+    event_sink(event_sink),
     disconnected(false)
 {
     socket.assign(boost::asio::local::stream_protocol(), native_socket);
@@ -413,11 +418,25 @@
 
                 rpc_report->event_parsing_succeeded(e);
 
-                surface_map->with_surface_do(e.surface.id,
-                    [&e](MirSurface* surface)
-                    {
-                        surface->handle_event(e);
-                    });
+                event_sink->handle_event(e);
+
+                // todo - surfaces should register with the event handler register.
+                if (e.type == mir_event_type_surface)
+                {
+                    surface_map->with_surface_do(e.surface.id,
+                        [&e](MirSurface* surface)
+                        {
+                            surface->handle_event(e);
+                        });
+                }
+                else if (e.type == mir_event_type_resize)
+                {
+                    surface_map->with_surface_do(e.resize.surface_id,
+                        [&e](MirSurface* surface)
+                        {
+                            surface->handle_event(e);
+                        });
+                }
             }
             else
             {
 
=== modified file 'src/client/rpc/mir_socket_rpc_channel.h'
--- src/client/rpc/mir_socket_rpc_channel.h	2014-05-07 02:56:33 +0000
+++ src/client/rpc/mir_socket_rpc_channel.h	2014-06-18 17:25:24 +0000
@@ -44,6 +44,7 @@
 class DisplayConfiguration;
 class SurfaceMap;
 class LifecycleControl;
+class EventSink;
 namespace rpc
 {
 
@@ -56,13 +57,15 @@
                         std::shared_ptr<SurfaceMap> const& surface_map,
                         std::shared_ptr<DisplayConfiguration> const& disp_config,
                         std::shared_ptr<RpcReport> const& rpc_report,
-                        std::shared_ptr<LifecycleControl> const& lifecycle_control);
+                        std::shared_ptr<LifecycleControl> const& lifecycle_control,
+                        std::shared_ptr<EventSink> const& event_sink);
 
     MirSocketRpcChannel(int native_socket,
                         std::shared_ptr<SurfaceMap> const& surface_map,
                         std::shared_ptr<DisplayConfiguration> const& disp_config,
                         std::shared_ptr<RpcReport> const& rpc_report,
-                        std::shared_ptr<LifecycleControl> const& lifecycle_control);
+                        std::shared_ptr<LifecycleControl> const& lifecycle_control,
+                        std::shared_ptr<EventSink> const& event_sink);
     ~MirSocketRpcChannel();
 
 private:
@@ -102,6 +105,7 @@
     std::shared_ptr<SurfaceMap> surface_map;
     std::shared_ptr<DisplayConfiguration> display_configuration;
     std::shared_ptr<LifecycleControl> lifecycle_control;
+    std::shared_ptr<EventSink> event_sink;
     std::atomic<bool> disconnected;
 };
 
 
=== modified file 'src/client/surface_map.cpp'
--- src/client/surface_map.cpp	2014-03-06 06:05:17 +0000
+++ src/client/surface_map.cpp	2014-06-18 17:25:24 +0000
@@ -17,8 +17,10 @@
  */
 
 #include "connection_surface_map.h"
+#include "mir_surface.h"
+
+#include <boost/throw_exception.hpp>
 #include <sstream>
-#include <boost/throw_exception.hpp>
 
 namespace mcl=mir::client;
 
@@ -26,10 +28,23 @@
 {
 }
 
+mcl::ConnectionSurfaceMap::~ConnectionSurfaceMap() noexcept
+{
+    // Unless the client has screwed up there should be no surfaces left
+    // here. (OTOH *we* don't need to leak memory when clients screw up.)
+    std::lock_guard<std::mutex> lk(guard);
+
+    for (auto const& surface :surfaces)
+    {
+        if (MirSurface::is_valid(surface.second))
+            delete surface.second;
+    }