Merge lp:~kdub/mir/common-fd-type into lp:mir/ubuntu

[Kevin DuBois]

add a common raii-friendly type for managing file descriptors.

add a common raii-friendly type for managing file descriptors, and have the protobuf sender and the android sync fences convert to using the new fence as a start. This is useful for me in sending a new fd on every send message, as I can just move the fence fd around.

We had a few things floating around for fd's... most of them just ints with close() in the right location. This mp aims to improve this situation a bit.

=== modified file '3rd_party/CMakeLists.txt'
--- 3rd_party/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ 3rd_party/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -25,8 +25,18 @@
   MIR_ANDROID_INPUT_COMPILE_FLAGS
   ${MIR_ANDROID_INPUT_COMPILE_FLAGS}
   PARENT_SCOPE)
+
+add_subdirectory(xcursor)
+list(
+  APPEND MIR_XCURSOR_INCLUDE_DIRECTORIES
+  ${CMAKE_CURRENT_SOURCE_DIR}/xcursor/
+)
+
+set(MIR_XCURSOR_INCLUDE_DIRECTORIES ${MIR_XCURSOR_INCLUDE_DIRECTORIES} PARENT_SCOPE)
   
 target_link_libraries(
   3rd_party
 
-  android-input)
+  android-input
+  xcursorloader
+)

=== added directory '3rd_party/xcursor'
=== added file '3rd_party/xcursor/CMakeLists.txt'
--- 3rd_party/xcursor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -0,0 +1,11 @@
+set(
+  XCURSOR_SOURCES
+
+  xcursor.c
+)
+
+add_library(
+  xcursorloader STATIC
+
+  ${XCURSOR_SOURCES}
+)

=== added file '3rd_party/xcursor/xcursor.c'
--- 3rd_party/xcursor/xcursor.c	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/xcursor.c	2014-07-11 20:27:44 +0000
@@ -0,0 +1,968 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "xcursor.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+
+/*
+ * From libXcursor/include/X11/extensions/Xcursor.h
+ */
+
+#define XcursorTrue	1
+#define XcursorFalse	0
+
+/*
+ * Cursor files start with a header.  The header
+ * contains a magic number, a version number and a
+ * table of contents which has type and offset information
+ * for the remaining tables in the file.
+ *
+ * File minor versions increment for compatible changes
+ * File major versions increment for incompatible changes (never, we hope)
+ *
+ * Chunks of the same type are always upward compatible.  Incompatible
+ * changes are made with new chunk types; the old data can remain under
+ * the old type.  Upward compatible changes can add header data as the
+ * header lengths are specified in the file.
+ *
+ *  File:
+ *	FileHeader
+ *	LISTofChunk
+ *
+ *  FileHeader:
+ *	CARD32		magic	    magic number
+ *	CARD32		header	    bytes in file header
+ *	CARD32		version	    file version
+ *	CARD32		ntoc	    number of toc entries
+ *	LISTofFileToc   toc	    table of contents
+ *
+ *  FileToc:
+ *	CARD32		type	    entry type
+ *	CARD32		subtype	    entry subtype (size for images)
+ *	CARD32		position    absolute file position
+ */
+
+#define XCURSOR_MAGIC	0x72756358  /* "Xcur" LSBFirst */
+
+/*
+ * Current Xcursor version number.  Will be substituted by configure
+ * from the version in the libXcursor configure.ac file.
+ */
+
+#define XCURSOR_LIB_MAJOR 1
+#define XCURSOR_LIB_MINOR 1
+#define XCURSOR_LIB_REVISION 13
+#define XCURSOR_LIB_VERSION	((XCURSOR_LIB_MAJOR * 10000) + \
+				 (XCURSOR_LIB_MINOR * 100) + \
+				 (XCURSOR_LIB_REVISION))
+
+/*
+ * This version number is stored in cursor files; changes to the
+ * file format require updating this version number
+ */
+#define XCURSOR_FILE_MAJOR	1
+#define XCURSOR_FILE_MINOR	0
+#define XCURSOR_FILE_VERSION	((XCURSOR_FILE_MAJOR << 16) | (XCURSOR_FILE_MINOR))
+#define XCURSOR_FILE_HEADER_LEN	(4 * 4)
+#define XCURSOR_FILE_TOC_LEN	(3 * 4)
+
+typedef struct _XcursorFileToc {
+    XcursorUInt	    type;	/* chunk type */
+    XcursorUInt	    subtype;	/* subtype (size for images) */
+    XcursorUInt	    position;	/* absolute position in file */
+} XcursorFileToc;
+
+typedef struct _XcursorFileHeader {
+    XcursorUInt	    magic;	/* magic number */
+    XcursorUInt	    header;	/* byte length of header */
+    XcursorUInt	    version;	/* file version number */
+    XcursorUInt	    ntoc;	/* number of toc entries */
+    XcursorFileToc  *tocs;	/* table of contents */
+} XcursorFileHeader;
+
+/*
+ * The rest of the file is a list of chunks, each tagged by type
+ * and version.
+ *
+ *  Chunk:
+ *	ChunkHeader
+ *	<extra type-specific header fields>
+ *	<type-specific data>
+ *
+ *  ChunkHeader:
+ *	CARD32	    header	bytes in chunk header + type header
+ *	CARD32	    type	chunk type
+ *	CARD32	    subtype	chunk subtype
+ *	CARD32	    version	chunk type version
+ */
+
+#define XCURSOR_CHUNK_HEADER_LEN    (4 * 4)
+
+typedef struct _XcursorChunkHeader {
+    XcursorUInt	    header;	/* bytes in chunk header */
+    XcursorUInt	    type;	/* chunk type */
+    XcursorUInt	    subtype;	/* chunk subtype (size for images) */
+    XcursorUInt	    version;	/* version of this type */
+} XcursorChunkHeader;
+
+/*
+ * Here's a list of the known chunk types
+ */
+
+/*
+ * Comments consist of a 4-byte length field followed by
+ * UTF-8 encoded text
+ *
+ *  Comment:
+ *	ChunkHeader header	chunk header
+ *	CARD32	    length	bytes in text
+ *	LISTofCARD8 text	UTF-8 encoded text
+ */
+
+#define XCURSOR_COMMENT_TYPE	    0xfffe0001
+#define XCURSOR_COMMENT_VERSION	    1
+#define XCURSOR_COMMENT_HEADER_LEN  (XCURSOR_CHUNK_HEADER_LEN + (1 *4))
+#define XCURSOR_COMMENT_COPYRIGHT   1
+#define XCURSOR_COMMENT_LICENSE	    2
+#define XCURSOR_COMMENT_OTHER	    3
+#define XCURSOR_COMMENT_MAX_LEN	    0x100000
+
+typedef struct _XcursorComment {
+    XcursorUInt	    version;
+    XcursorUInt	    comment_type;
+    char	    *comment;
+} XcursorComment;
+
+/*
+ * Each cursor image occupies a separate image chunk.
+ * The length of the image header follows the chunk header
+ * so that future versions can extend the header without
+ * breaking older applications
+ *
+ *  Image:
+ *	ChunkHeader	header	chunk header
+ *	CARD32		width	actual width
+ *	CARD32		height	actual height
+ *	CARD32		xhot	hot spot x
+ *	CARD32		yhot	hot spot y
+ *	CARD32		delay	animation delay
+ *	LISTofCARD32	pixels	ARGB pixels
+ */
+
+#define XCURSOR_IMAGE_TYPE    	    0xfffd0002
+#define XCURSOR_IMAGE_VERSION	    1
+#define XCURSOR_IMAGE_HEADER_LEN    (XCURSOR_CHUNK_HEADER_LEN + (5*4))
+#define XCURSOR_IMAGE_MAX_SIZE	    0x7fff	/* 32767x32767 max cursor size */
+
+typedef struct _XcursorFile XcursorFile;
+
+struct _XcursorFile {
+    void    *closure;
+    int	    (*read)  (XcursorFile *file, unsigned char *buf, int len);
+    int	    (*write) (XcursorFile *file, unsigned char *buf, int len);
+    int	    (*seek)  (XcursorFile *file, long offset, int whence);
+};
+
+typedef struct _XcursorComments {
+    int		    ncomment;	/* number of comments */
+    XcursorComment  **comments;	/* array of XcursorComment pointers */
+} XcursorComments;
+
+/*
+ * From libXcursor/src/file.c
+ */
+
+static XcursorImage *
+XcursorImageCreate (int width, int height)
+{
+    XcursorImage    *image;
+
+    image = malloc (sizeof (XcursorImage) +
+		    width * height * sizeof (XcursorPixel));
+    if (!image)
+	return NULL;
+    image->version = XCURSOR_IMAGE_VERSION;
+    image->pixels = (XcursorPixel *) (image + 1);
+    image->size = width > height ? width : height;
+    image->width = width;
+    image->height = height;
+    image->delay = 0;
+    return image;
+}
+
+static void
+XcursorImageDestroy (XcursorImage *image)
+{
+    free (image);
+}
+
+static XcursorImages *
+XcursorImagesCreate (int size)
+{
+    XcursorImages   *images;
+
+    images = malloc (sizeof (XcursorImages) +
+		     size * sizeof (XcursorImage *));
+    if (!images)
+	return NULL;
+    images->nimage = 0;
+    images->images = (XcursorImage **) (images + 1);
+    images->name = NULL;
+    return images;
+}
+
+void
+XcursorImagesDestroy (XcursorImages *images)
+{
+    int	n;
+
+    if (!images)
+        return;
+
+    for (n = 0; n < images->nimage; n++)
+	XcursorImageDestroy (images->images[n]);
+    if (images->name)
+	free (images->name);
+    free (images);
+}
+
+static void
+XcursorImagesSetName (XcursorImages *images, const char *name)
+{
+    char    *new;
+
+    if (!images || !name)
+        return;
+
+    new = malloc (strlen (name) + 1);
+
+    if (!new)
+	return;
+
+    strcpy (new, name);
+    if (images->name)
+	free (images->name);
+    images->name = new;
+}
+
+static XcursorBool
+_XcursorReadUInt (XcursorFile *file, XcursorUInt *u)
+{
+    unsigned char   bytes[4];
+
+    if (!file || !u)
+        return XcursorFalse;
+
+    if ((*file->read) (file, bytes, 4) != 4)
+	return XcursorFalse;
+    *u = ((bytes[0] << 0) |
+	  (bytes[1] << 8) |
+	  (bytes[2] << 16) |
+	  (bytes[3] << 24));
+    return XcursorTrue;
+}
+
+static void
+_XcursorFileHeaderDestroy (XcursorFileHeader *fileHeader)
+{
+    free (fileHeader);
+}
+
+static XcursorFileHeader *
+_XcursorFileHeaderCreate (int ntoc)
+{
+    XcursorFileHeader	*fileHeader;
+
+    if (ntoc > 0x10000)
+	return NULL;
+    fileHeader = malloc (sizeof (XcursorFileHeader) +
+			 ntoc * sizeof (XcursorFileToc));
+    if (!fileHeader)
+	return NULL;
+    fileHeader->magic = XCURSOR_MAGIC;
+    fileHeader->header = XCURSOR_FILE_HEADER_LEN;
+    fileHeader->version = XCURSOR_FILE_VERSION;
+    fileHeader->ntoc = ntoc;
+    fileHeader->tocs = (XcursorFileToc *) (fileHeader + 1);
+    return fileHeader;
+}
+
+static XcursorFileHeader *
+_XcursorReadFileHeader (XcursorFile *file)
+{
+    XcursorFileHeader	head, *fileHeader;
+    XcursorUInt		skip;
+    unsigned int	n;
+
+    if (!file)
+        return NULL;
+
+    if (!_XcursorReadUInt (file, &head.magic))
+	return NULL;
+    if (head.magic != XCURSOR_MAGIC)
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.header))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.version))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.ntoc))
+	return NULL;
+    skip = head.header - XCURSOR_FILE_HEADER_LEN;
+    if (skip)
+	if ((*file->seek) (file, skip, SEEK_CUR) == EOF)
+	    return NULL;
+    fileHeader = _XcursorFileHeaderCreate (head.ntoc);
+    if (!fileHeader)
+	return NULL;
+    fileHeader->magic = head.magic;
+    fileHeader->header = head.header;
+    fileHeader->version = head.version;
+    fileHeader->ntoc = head.ntoc;
+    for (n = 0; n < fileHeader->ntoc; n++)
+    {
+	if (!_XcursorReadUInt (file, &fileHeader->tocs[n].type))
+	    break;
+	if (!_XcursorReadUInt (file, &fileHeader->tocs[n].subtype))
+	    break;
+	if (!_XcursorReadUInt (file, &fileHeader->tocs[n].position))
+	    break;
+    }
+    if (n != fileHeader->ntoc)
+    {
+	_XcursorFileHeaderDestroy (fileHeader);
+	return NULL;
+    }
+    return fileHeader;
+}
+
+static XcursorBool
+_XcursorSeekToToc (XcursorFile		*file,
+		   XcursorFileHeader	*fileHeader,
+		   int			toc)
+{
+    if (!file || !fileHeader || \
+        (*file->seek) (file, fileHeader->tocs[toc].position, SEEK_SET) == EOF)
+	return XcursorFalse;
+    return XcursorTrue;
+}
+
+static XcursorBool
+_XcursorFileReadChunkHeader (XcursorFile	*file,
+			     XcursorFileHeader	*fileHeader,
+			     int		toc,
+			     XcursorChunkHeader	*chunkHeader)
+{
+    if (!file || !fileHeader || !chunkHeader)
+        return XcursorFalse;
+    if (!_XcursorSeekToToc (file, fileHeader, toc))
+	return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->header))
+	return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->type))
+	return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->subtype))
+	return XcursorFalse;
+    if (!_XcursorReadUInt (file, &chunkHeader->version))
+	return XcursorFalse;
+    /* sanity check */
+    if (chunkHeader->type != fileHeader->tocs[toc].type ||
+	chunkHeader->subtype != fileHeader->tocs[toc].subtype)
+	return XcursorFalse;
+    return XcursorTrue;
+}
+
+#define dist(a,b)   ((a) > (b) ? (a) - (b) : (b) - (a))
+
+static XcursorDim
+_XcursorFindBestSize (XcursorFileHeader *fileHeader,
+		      XcursorDim	size,
+		      int		*nsizesp)
+{
+    unsigned int n;
+    int		nsizes = 0;
+    XcursorDim	bestSize = 0;
+    XcursorDim	thisSize;
+
+    if (!fileHeader || !nsizesp)
+        return 0;
+
+    for (n = 0; n < fileHeader->ntoc; n++)
+    {
+	if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE)
+	    continue;
+	thisSize = fileHeader->tocs[n].subtype;
+	if (!bestSize || dist (thisSize, size) < dist (bestSize, size))
+	{
+	    bestSize = thisSize;
+	    nsizes = 1;
+	}
+	else if (thisSize == bestSize)
+	    nsizes++;
+    }
+    *nsizesp = nsizes;
+    return bestSize;
+}
+
+static int
+_XcursorFindImageToc (XcursorFileHeader	*fileHeader,
+		      XcursorDim	size,
+		      int		count)
+{
+    unsigned int	toc;
+    XcursorDim		thisSize;
+
+    if (!fileHeader)
+        return 0;
+
+    for (toc = 0; toc < fileHeader->ntoc; toc++)
+    {
+	if (fileHeader->tocs[toc].type != XCURSOR_IMAGE_TYPE)
+	    continue;
+	thisSize = fileHeader->tocs[toc].subtype;
+	if (thisSize != size)
+	    continue;
+	if (!count)
+	    break;
+	count--;
+    }
+    if (toc == fileHeader->ntoc)
+	return -1;
+    return toc;
+}
+
+static XcursorImage *
+_XcursorReadImage (XcursorFile		*file,
+		   XcursorFileHeader	*fileHeader,
+		   int			toc)
+{
+    XcursorChunkHeader	chunkHeader;
+    XcursorImage	head;
+    XcursorImage	*image;
+    int			n;
+    XcursorPixel	*p;
+
+    if (!file || !fileHeader)
+        return NULL;
+
+    if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.width))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.height))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.xhot))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.yhot))
+	return NULL;
+    if (!_XcursorReadUInt (file, &head.delay))
+	return NULL;
+    /* sanity check data */
+    if (head.width >= 0x10000 || head.height > 0x10000)
+	return NULL;
+    if (head.width == 0 || head.height == 0)
+	return NULL;
+    if (head.xhot > head.width || head.yhot > head.height)
+	return NULL;
+
+    /* Create the image and initialize it */
+    image = XcursorImageCreate (head.width, head.height);
+    if (image == NULL)
+	    return NULL;
+    if (chunkHeader.version < image->version)
+	image->version = chunkHeader.version;
+    image->size = chunkHeader.subtype;
+    image->xhot = head.xhot;
+    image->yhot = head.yhot;
+    image->delay = head.delay;
+    n = image->width * image->height;
+    p = image->pixels;
+    while (n--)
+    {
+	if (!_XcursorReadUInt (file, p))
+	{
+	    XcursorImageDestroy (image);
+	    return NULL;
+	}
+	p++;
+    }
+    return image;
+}
+
+static XcursorImages *
+XcursorXcFileLoadImages (XcursorFile *file, int size)
+{
+    XcursorFileHeader	*fileHeader;
+    XcursorDim		bestSize;
+    int			nsize;
+    XcursorImages	*images;
+    int			n;
+    int			toc;
+
+    if (!file || size < 0)
+	return NULL;
+    fileHeader = _XcursorReadFileHeader (file);
+    if (!fileHeader)
+	return NULL;
+    bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
+    if (!bestSize)
+    {
+        _XcursorFileHeaderDestroy (fileHeader);
+	return NULL;
+    }
+    images = XcursorImagesCreate (nsize);
+    if (!images)
+    {
+        _XcursorFileHeaderDestroy (fileHeader);
+	return NULL;
+    }
+    for (n = 0; n < nsize; n++)
+    {
+	toc = _XcursorFindImageToc (fileHeader, bestSize, n);
+	if (toc < 0)
+	    break;
+	images->images[images->nimage] = _XcursorReadImage (file, fileHeader,
+							    toc);
+	if (!images->images[images->nimage])
+	    break;
+	images->nimage++;
+    }
+    _XcursorFileHeaderDestroy (fileHeader);
+    if (images->nimage != nsize)
+    {
+	XcursorImagesDestroy (images);
+	images = NULL;
+    }
+    return images;
+}
+
+static int
+_XcursorStdioFileRead (XcursorFile *file, unsigned char *buf, int len)
+{
+    FILE    *f = file->closure;
+    return fread (buf, 1, len, f);
+}
+
+static int
+_XcursorStdioFileWrite (XcursorFile *file, unsigned char *buf, int len)
+{
+    FILE    *f = file->closure;
+    return fwrite (buf, 1, len, f);
+}
+
+static int
+_XcursorStdioFileSeek (XcursorFile *file, long offset, int whence)
+{
+    FILE    *f = file->closure;
+    return fseek (f, offset, whence);
+}
+
+static void
+_XcursorStdioFileInitialize (FILE *stdfile, XcursorFile *file)
+{
+    file->closure = stdfile;
+    file->read = _XcursorStdioFileRead;
+    file->write = _XcursorStdioFileWrite;
+    file->seek = _XcursorStdioFileSeek;
+}
+
+static XcursorImages *
+XcursorFileLoadImages (FILE *file, int size)
+{
+    XcursorFile	f;
+
+    if (!file)
+        return NULL;
+
+    _XcursorStdioFileInitialize (file, &f);
+    return XcursorXcFileLoadImages (&f, size);
+}
+
+/*
+ * From libXcursor/src/library.c
+ */
+
+#ifndef ICONDIR
+#define ICONDIR "/usr/X11R6/lib/X11/icons"
+#endif
+
+#ifndef XCURSORPATH
+#define XCURSORPATH "~/.icons:/usr/share/icons:/usr/share/pixmaps:~/.cursors:/usr/share/cursors/xorg-x11:"ICONDIR
+#endif
+
+static const char *
+XcursorLibraryPath (void)
+{
+    static const char	*path;
+
+    if (!path)
+    {
+	path = getenv ("XCURSOR_PATH");
+	if (!path)
+	    path = XCURSORPATH;
+    }
+    return path;
+}
+
+static  void
+_XcursorAddPathElt (char *path, const char *elt, int len)
+{
+    int	    pathlen = strlen (path);
+
+    /* append / if the path doesn't currently have one */
+    if (path[0] == '\0' || path[pathlen - 1] != '/')
+    {
+	strcat (path, "/");
+	pathlen++;
+    }
+    if (len == -1)
+	len = strlen (elt);
+    /* strip leading slashes */
+    while (len && elt[0] == '/')
+    {
+	elt++;
+	len--;
+    }
+    strncpy (path + pathlen, elt, len);
+    path[pathlen + len] = '\0';
+}
+
+static char *
+_XcursorBuildThemeDir (const char *dir, const char *theme)
+{
+    const char	    *colon;
+    const char	    *tcolon;
+    char	    *full;
+    char	    *home;
+    int		    dirlen;
+    int		    homelen;
+    int		    themelen;
+    int		    len;
+
+    if (!dir || !theme)
+        return NULL;
+
+    colon = strchr (dir, ':');
+    if (!colon)
+	colon = dir + strlen (dir);
+
+    dirlen = colon - dir;
+
+    tcolon = strchr (theme, ':');
+    if (!tcolon)
+	tcolon = theme + strlen (theme);
+
+    themelen = tcolon - theme;
+
+    home = NULL;
+    homelen = 0;
+    if (*dir == '~')
+    {
+	home = getenv ("HOME");
+	if (!home)
+	    return NULL;
+	homelen = strlen (home);
+	dir++;
+	dirlen--;
+    }
+
+    /*
+     * add space for any needed directory separators, one per component,
+     * and one for the trailing null
+     */
+    len = 1 + homelen + 1 + dirlen + 1 + themelen + 1;
+
+    full = malloc (len);
+    if (!full)
+	return NULL;
+    full[0] = '\0';
+
+    if (home)
+	_XcursorAddPathElt (full, home, -1);
+    _XcursorAddPathElt (full, dir, dirlen);
+    _XcursorAddPathElt (full, theme, themelen);
+    return full;
+}
+
+static char *
+_XcursorBuildFullname (const char *dir, const char *subdir, const char *file)
+{
+    char    *full;
+
+    if (!dir || !subdir || !file)
+        return NULL;
+
+    full = malloc (strlen (dir) + 1 + strlen (subdir) + 1 + strlen (file) + 1);
+    if (!full)
+	return NULL;
+    full[0] = '\0';
+    _XcursorAddPathElt (full, dir, -1);
+    _XcursorAddPathElt (full, subdir, -1);
+    _XcursorAddPathElt (full, file, -1);
+    return full;
+}
+
+static const char *
+_XcursorNextPath (const char *path)
+{
+    char    *colon = strchr (path, ':');
+
+    if (!colon)
+	return NULL;
+    return colon + 1;
+}
+
+#define XcursorWhite(c)	((c) == ' ' || (c) == '\t' || (c) == '\n')
+#define XcursorSep(c) ((c) == ';' || (c) == ',')
+
+static char *
+_XcursorThemeInherits (const char *full)
+{
+    char    line[8192];
+    char    *result = NULL;
+    FILE    *f;
+
+    if (!full)
+        return NULL;
+
+    f = fopen (full, "r");
+    if (f)
+    {
+	while (fgets (line, sizeof (line), f))
+	{
+	    if (!strncmp (line, "Inherits", 8))
+	    {
+		char    *l = line + 8;
+		char    *r;
+		while (*l == ' ') l++;
+		if (*l != '=') continue;
+		l++;
+		while (*l == ' ') l++;
+		result = malloc (strlen (l) + 1);
+		if (result)
+		{
+		    r = result;
+		    while (*l)
+		    {
+			while (XcursorSep(*l) || XcursorWhite (*l)) l++;
+			if (!*l)
+			    break;
+			if (r != result)
+			    *r++ = ':';
+			while (*l && !XcursorWhite(*l) &&
+			       !XcursorSep(*l))
+			    *r++ = *l++;
+		    }
+		    *r++ = '\0';
+		}
+		break;
+	    }
+	}
+	fclose (f);
+    }
+    return result;
+}
+
+static FILE *
+XcursorScanTheme (const char *theme, const char *name)
+{
+    FILE	*f = NULL;
+    char	*full;
+    char	*dir;
+    const char  *path;
+    char	*inherits = NULL;
+    const char	*i;
+    
+    if (!theme || !name)
+        return NULL;
+
+    /*
+     * Scan this theme
+     */
+    for (path = XcursorLibraryPath ();
+	 path && f == NULL;
+	 path = _XcursorNextPath (path))
+    {
+	dir = _XcursorBuildThemeDir (path, theme);
+	if (dir)
+	{
+	    full = _XcursorBuildFullname (dir, "cursors", name);
+	    if (full)
+	    {
+		f = fopen (full, "r");
+		free (full);
+	    }
+	    if (!f && !inherits)
+	    {
+		full = _XcursorBuildFullname (dir, "", "index.theme");
+		if (full)
+		{
+		    inherits = _XcursorThemeInherits (full);
+		    free (full);
+		}
+	    }
+	    free (dir);
+	}
+    }
+    /*
+     * Recurse to scan inherited themes
+     */
+    for (i = inherits; i && f == NULL; i = _XcursorNextPath (i))
+	f = XcursorScanTheme (i, name);
+    if (inherits != NULL)
+	free (inherits);
+    return f;
+}
+
+XcursorImages *
+XcursorLibraryLoadImages (const char *file, const char *theme, int size)
+{
+    FILE	    *f = NULL;
+    XcursorImages   *images = NULL;
+
+    if (!file)
+        return NULL;
+
+    if (theme)
+	f = XcursorScanTheme (theme, file);
+    if (!f)
+	f = XcursorScanTheme ("default", file);
+    if (f)
+    {
+	images = XcursorFileLoadImages (f, size);
+	if (images)
+	    XcursorImagesSetName (images, file);
+	fclose (f);
+    }
+    return images;
+}
+
+static void
+load_all_cursors_from_dir(const char *path, int size,
+			  void (*load_callback)(XcursorImages *, void *),
+			  void *user_data)
+{
+	FILE *f;
+	DIR *dir = opendir(path);
+	struct dirent *ent;
+	char *full;
+	XcursorImages *images;
+
+	if (!dir)
+		return;
+
+	for(ent = readdir(dir); ent; ent = readdir(dir)) {
+#ifdef _DIRENT_HAVE_D_TYPE
+		if (ent->d_type != DT_UNKNOWN &&
+		    (ent->d_type != DT_REG && ent->d_type != DT_LNK))
+			continue;
+#endif
+
+		full = _XcursorBuildFullname(path, "", ent->d_name);
+		if (!full)
+			continue;
+
+		f = fopen(full, "r");
+		if (!f) {
+			free(full);
+			continue;
+		}
+
+		images = XcursorFileLoadImages(f, size);
+
+		if (images) {
+			XcursorImagesSetName(images, ent->d_name);
+			load_callback(images, user_data);
+		}
+
+		fclose (f);
+		free(full);
+	}
+
+	closedir(dir);
+}
+
+/** Load all the cursor of a theme
+ *
+ * This function loads all the cursor images of a given theme and its
+ * inherited themes. Each cursor is loaded into an XcursorImages object
+ * which is passed to the caller's load callback. If a cursor appears
+ * more than once across all the inherited themes, the load callback
+ * will be called multiple times, with possibly different XcursorImages
+ * object which have the same name. The user is expected to destroy the
+ * XcursorImages objects passed to the callback with
+ * XcursorImagesDestroy().
+ *
+ * \param theme The name of theme that should be loaded
+ * \param size The desired size of the cursor images
+ * \param load_callback A callback function that will be called
+ * for each cursor loaded. The first parameter is the XcursorImages
+ * object representing the loaded cursor and the second is a pointer
+ * to data provided by the user.
+ * \param user_data The data that should be passed to the load callback
+ */
+void
+xcursor_load_theme(const char *theme, int size,
+		    void (*load_callback)(XcursorImages *, void *),
+		    void *user_data)
+{
+	char *full, *dir;
+	char *inherits = NULL;
+	const char *path, *i;
+
+	if (!theme)
+		theme = "default";
+
+	for (path = XcursorLibraryPath();
+	     path;
+	     path = _XcursorNextPath(path)) {
+		dir = _XcursorBuildThemeDir(path, theme);
+		if (!dir)
+			continue;
+
+		full = _XcursorBuildFullname(dir, "cursors", "");
+
+		if (full) {
+			load_all_cursors_from_dir(full, size, load_callback,
+						  user_data);
+			free(full);
+		}
+
+		if (!inherits) {
+			full = _XcursorBuildFullname(dir, "", "index.theme");
+			if (full) {
+				inherits = _XcursorThemeInherits(full);
+				free(full);
+			}
+		}
+
+		free(dir);
+	}
+
+	for (i = inherits; i; i = _XcursorNextPath(i))
+		xcursor_load_theme(i, size, load_callback, user_data);
+
+	if (inherits)
+		free(inherits);
+}

=== added file '3rd_party/xcursor/xcursor.h'
--- 3rd_party/xcursor/xcursor.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/xcursor/xcursor.h	2014-07-11 20:27:44 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef XCURSOR_H
+#define XCURSOR_H
+
+#include <stdint.h>
+
+
+typedef int		XcursorBool;
+typedef uint32_t XcursorUInt;
+
+typedef XcursorUInt	XcursorDim;
+typedef XcursorUInt	XcursorPixel;
+
+typedef struct _XcursorImage {
+    XcursorUInt	    version;	/* version of the image data */
+    XcursorDim	    size;	/* nominal size for matching */
+    XcursorDim	    width;	/* actual width */
+    XcursorDim	    height;	/* actual height */
+    XcursorDim	    xhot;	/* hot spot x (must be inside image) */
+    XcursorDim	    yhot;	/* hot spot y (must be inside image) */
+    XcursorUInt	    delay;	/* animation delay to next frame (ms) */
+    XcursorPixel    *pixels;	/* pointer to pixels */
+} XcursorImage;
+
+/*
+ * Other data structures exposed by the library API
+ */
+typedef struct _XcursorImages {
+    int		    nimage;	/* number of images */
+    XcursorImage    **images;	/* array of XcursorImage pointers */
+    char	    *name;	/* name used to load images */
+} XcursorImages;
+
+XcursorImages *
+XcursorLibraryLoadImages (const char *file, const char *theme, int size);
+
+void
+XcursorImagesDestroy (XcursorImages *images);
+
+void
+xcursor_load_theme(const char *theme, int size,
+		    void (*load_callback)(XcursorImages *, void *),
+		    void *user_data);
+#endif

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-06-25 07:27:23 +0000
+++ CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -27,7 +27,7 @@
 set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
 
 set(MIR_VERSION_MAJOR 0)
-set(MIR_VERSION_MINOR 4) # This should change at least with every MIRSERVER_ABI
+set(MIR_VERSION_MINOR 5) # 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)
@@ -47,15 +47,21 @@
 include (cmake/PrePush.cmake)
 include (GNUInstallDirs)
 
+set(build_types "None;Debug;Release;RelWithDebInfo;MinSizeRel;Coverage;AddressSanitizer")
+# Change informational string for CMAKE_BUILD_TYPE
+set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "${build_types}" FORCE)
+# Enable cmake-gui to display a drop down list for CMAKE_BUILD_TYPE
+set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${build_types}")
+
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -g -Werror -Wall -pedantic -Wextra -fPIC")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -g -std=c++0x -Werror -Wall -fno-strict-aliasing -pedantic -Wnon-virtual-dtor -Wextra -fPIC")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-undefined")
 
 if ("${CMAKE_CXX_COMPILER}" MATCHES "clang")
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage -Wno-mismatched-tags")
 endif()
 
+string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower)
+
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov
 # Usage:
@@ -64,12 +70,23 @@
 #  * Find html report in subdir coveragereport
 #  * Find xml report feasible for jenkins in coverage.xml
 #####################################################################
-IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
-  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
-  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
-ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
+if(cmake_build_type_lower MATCHES "coverage")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs")
+endif()
+
+if(cmake_build_type_lower MATCHES "addresssanitizer")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fsanitize=address")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
+else()
+  # AddressSanitizer builds fail if we disallow undefined symbols
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-undefined")
+endif()
 
 enable_testing()
 
@@ -141,6 +158,7 @@
 
 set(MIR_ANDROID_INCLUDE_DIRECTORIES) # to be filled by android-input
 set(MIR_ANDROID_INPUT_COMPILE_FLAGS) # to be filled by android-input
+set(MIR_XCURSOR_INCLUDE_DIRECTORIES)
 set(MIR_3RD_PARTY_INCLUDE_DIRECTORIES)
 add_subdirectory(3rd_party/)
 

=== modified file 'debian/changelog'
--- debian/changelog	2014-07-01 15:54:36 +0000
+++ debian/changelog	2014-07-11 20:27:44 +0000
@@ -1,3 +1,9 @@
+mir (0.5.0-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Under development
+
+ -- Daniel van Vugt <[e-mail]>  Fri, 04 Jul 2014 12:45:30 +0800
+
 mir (0.4.0+14.10.20140701.1-0ubuntu1) utopic; urgency=medium
 
   * New upstream release 0.4.0 (https://launchpad.net/mir/+milestone/0.4.0)
@@ -5,7 +11,6 @@
       . Add surface attribute for visibility.
       . Add surface orientation API.
     - mirserver ABI bumped to 22. Shells need rebuilding.
-      . Allow setting the orientation of a server surface.
       . Change compositor::Scene to expose compositor::SceneElements instead
         of graphics::Renderables.
       . Change various input and Surface classes to support the client cursor
@@ -16,18 +21,29 @@
         mg::Renderables.
       . Add visibility tracking to mc::SceneElement interface and
         implementations.
-      . Unregister FD Handler from EventHandlerRegister.
-      . Sending user input events through Surfaces.
       . Move InputChannelFactory into DefaultServerConfiguration.
-      . Ensure default input region is updated when surface is resized. (LP: #1332632)
-    - android: support alpha blending overlays together in HWC. Bumps
-      android-headers version requirement from 4.2.2 to 4.4.2. (LP: #1329879)
-    - android: designate the buffer usage when attempting to access or
-      update the fence associated with the native buffer. (LP: #1329868)
+    - Unregister FD Handler from EventHandlerRegister.
+    - Sending user input events through Surfaces.
+    - Allow setting the orientation of a server surface.
     - Enable client cursor API.
     - Enable support for USB touchscreens.
     - Various test improvements.
-    - Ensure the_cursor() is not null. (LP: #1334010)
+    - Bugs fixed:
+      . can't display toolbar after dismissing it (LP: #1332632)
+      . [regression] demo client connection crashes the server (LP: #1334010)
+      . demo server locks up in certain scenarios with --disable-overlays
+        false when starting/stopping second clients (LP: #1329868)
+      . MultiThreadedCompositor deadlocks (LP: #1335311)
+      . Intermittent memory error in
+        ClientSurfaceEvents.client_can_query_current_orientation (LP: #1335819)
+      . Intermittent hang & fail in mir_acceptance_tests.TestClientCursorAPI.*
+        (LP: #1332011)
+      . MirClientSurfaceTests tests leak fds and eventually hang when ran
+        repeatedly (LP: #1333673)
+      . [testfail] Intermittent "Invalid read" in MirSurfaceSwapBuffersTest.
+        swap_buffers_does_not_block_when_surface_is_not_composited
+        (LP: #1334287)
+      . android: support alpha blending during hwc overlay (LP: #1329879)
 
  -- Ubuntu daily release <[e-mail]>  Tue, 01 Jul 2014 15:54:36 +0000
 

=== modified file 'debian/control'
--- debian/control	2014-06-27 06:10:24 +0000
+++ debian/control	2014-07-11 20:27:44 +0000
@@ -10,6 +10,10 @@
                doxygen,
                xsltproc,
                graphviz,
+# We rely on C++11 features, and to prevent from ABI breaks
+# in libstdc++ causing us issues, we explicitly select a G++
+# version.
+               g++-4.9,
                libboost-dev,
                libboost-chrono-dev,
                libboost-date-time-dev,

=== modified file 'debian/rules'
--- debian/rules	2014-04-15 17:11:14 +0000
+++ debian/rules	2014-07-11 20:27:44 +0000
@@ -6,6 +6,13 @@
 
 export DPKG_GENSYMBOLS_CHECK_LEVEL = 4
 
+include /usr/share/dpkg/default.mk
+
+# Explicitly selecting a G{CC,++}-version here to avoid accidental
+# ABI breaks introduced by toolchain updates.
+export CC=$(DEB_HOST_GNU_TYPE)-gcc-4.9
+export CXX=$(DEB_HOST_GNU_TYPE)-g++-4.9
+
 %:
 	dh $@ --parallel --fail-missing
 

=== modified file 'examples/eglcounter.cpp'
--- examples/eglcounter.cpp	2014-06-05 21:28:43 +0000
+++ examples/eglcounter.cpp	2014-07-11 20:27:44 +0000
@@ -201,7 +201,7 @@
 };
 
 /* Colours from http://design.ubuntu.com/brand/colour-palette */
-#define MID_AUBERGINE(x) x*0.368627451f, x*0.152941176f, x*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[])

=== modified file 'examples/egltriangle.c'
--- examples/egltriangle.c	2014-06-09 17:16:32 +0000
+++ examples/egltriangle.c	2014-07-11 20:27:44 +0000
@@ -44,7 +44,7 @@
 }
 
 /* Colours from http://design.ubuntu.com/brand/colour-palette */
-#define MID_AUBERGINE(x) x*0.368627451f, x*0.152941176f, x*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[])

=== modified file 'examples/minimal_server.cpp'
--- examples/minimal_server.cpp	2014-04-30 07:05:40 +0000
+++ examples/minimal_server.cpp	2014-07-11 20:27:44 +0000
@@ -17,12 +17,20 @@
  */
 
 #include "mir/default_server_configuration.h"
+#include "mir/report_exception.h"
 #include "mir/run_mir.h"
 
+#include <iostream>
+
 int main(int argc, char const* argv[])
+try
 {
     mir::DefaultServerConfiguration config(argc, argv);
     run_mir(config, [](mir::DisplayServer&){} );
     return 0;
 }
-
+catch (...)
+{
+    mir::report_exception(std::cerr);
+    return 1;
+}

=== modified file 'examples/multiwin.c'
--- examples/multiwin.c	2014-03-06 06:05:17 +0000
+++ examples/multiwin.c	2014-07-11 20:27:44 +0000
@@ -44,6 +44,13 @@
     }
 }
 
+static void premultiply_alpha(Color *c)
+{
+    c->r = (unsigned)c->r * c->a / 255U;
+    c->g = (unsigned)c->g * c->a / 255U;
+    c->b = (unsigned)c->b * c->a / 255U;
+}
+
 static void put_pixels(void *where, int count, MirPixelFormat format,
                        const Color *color)
 {
@@ -187,6 +194,7 @@
     win[0].fill.g = 0x00;
     win[0].fill.b = 0x00;
     win[0].fill.a = 0x50;
+    premultiply_alpha(&win[0].fill);
 
     parm.name = "green";
     parm.width = 300;
@@ -196,6 +204,7 @@
     win[1].fill.g = 0xff;
     win[1].fill.b = 0x00;
     win[1].fill.a = 0x50;
+    premultiply_alpha(&win[1].fill);
 
     parm.name = "blue";
     parm.width = 150;
@@ -205,6 +214,7 @@
     win[2].fill.g = 0x00;
     win[2].fill.b = 0xff;
     win[2].fill.a = 0x50;
+    premultiply_alpha(&win[2].fill);
 
     signal(SIGINT, shutdown);
     signal(SIGTERM, shutdown);

=== modified file 'include/client/mir_toolkit/mir_prompt_session.h'
--- include/client/mir_toolkit/mir_prompt_session.h	2014-06-13 10:02:22 +0000
+++ include/client/mir_toolkit/mir_prompt_session.h	2014-07-11 20:27:44 +0000
@@ -79,6 +79,23 @@
  */
 void mir_prompt_session_release_sync(MirPromptSession *prompt_session);
 
+/**
+ * Test for a valid prompt session
+ *   \param [in] prompt_session  The prompt session
+ *   \return                     True if prompt_session is valid, false otherwise
+ */
+MirBool mir_prompt_session_is_valid(MirPromptSession *prompt_session);
+
+/**
+ * Retrieve a text description of the last error. The returned string is owned
+ * by the library and remains valid until the prompt session has been released.
+ *   \param [in] prompt_session  The prompt session
+ *   \return                 A text description of any error resulting in an
+ *                           invalid connection, or the empty string "" if the
+ *                           connection is valid.
+ */
+char const *mir_prompt_session_error_message(MirPromptSession *prompt_session);
+
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/platform/mir/graphics/cursor_image.h'
--- include/platform/mir/graphics/cursor_image.h	2014-04-28 23:15:05 +0000
+++ include/platform/mir/graphics/cursor_image.h	2014-07-11 20:27:44 +0000
@@ -21,6 +21,7 @@
 #define MIR_GRAPHICS_CURSOR_IMAGE_H_
 
 #include "mir/geometry/size.h"
+#include "mir/geometry/displacement.h"
 
 namespace mir
 {
@@ -33,6 +34,12 @@
 
     virtual void const* as_argb_8888() const = 0;
     virtual geometry::Size size() const = 0;
+    
+    // We use "hotspot" to mean the offset within a cursor image
+    // which should be placed at the onscreen
+    // location of the pointer.
+    virtual geometry::Displacement hotspot() const = 0;
+    
 
 protected:
     CursorImage() = default;

=== modified file 'include/platform/mir/options/configuration.h'
--- include/platform/mir/options/configuration.h	2014-03-26 05:48:59 +0000
+++ include/platform/mir/options/configuration.h	2014-07-11 20:27:44 +0000
@@ -28,6 +28,7 @@
 namespace options
 {
 extern char const* const server_socket_opt;
+extern char const* const prompt_socket_opt;
 extern char const* const no_server_socket_opt;
 extern char const* const enable_input_opt;
 extern char const* const session_mediator_report_opt;

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-06-23 17:40:57 +0000
+++ include/server/mir/default_server_configuration.h	2014-07-11 20:27:44 +0000
@@ -98,6 +98,7 @@
 }
 namespace graphics
 {
+class NativePlatform;
 class Platform;
 class Display;
 class BufferInitializer;
@@ -105,7 +106,6 @@
 class GraphicBufferAllocator;
 class Cursor;
 class CursorImage;
-class CursorImages;
 class GLConfig;
 class GLProgramFactory;
 namespace nested { class HostConnection; }
@@ -124,6 +124,7 @@
 class InputSendObserver;
 class NestedInputRelay;
 class EventHandler;
+class CursorImages;
 namespace android
 {
 class InputRegistrar;
@@ -157,6 +158,7 @@
      * dependencies of DisplayServer on the rest of the Mir
      *  @{ */
     virtual std::shared_ptr<frontend::Connector>    the_connector();
+    virtual std::shared_ptr<frontend::Connector>    the_prompt_connector();
     virtual std::shared_ptr<graphics::Display>      the_display();
     virtual std::shared_ptr<compositor::Compositor> the_compositor();
     virtual std::shared_ptr<input::InputManager>    the_input_manager();
@@ -164,6 +166,7 @@
     virtual std::shared_ptr<ServerStatusListener>   the_server_status_listener();
     virtual std::shared_ptr<DisplayChanger>         the_display_changer();
     virtual std::shared_ptr<graphics::Platform>     the_graphics_platform();
+    virtual std::shared_ptr<graphics::NativePlatform>  the_graphics_native_platform();
     virtual std::shared_ptr<input::InputConfiguration> the_input_configuration();
     virtual std::shared_ptr<input::InputDispatcher> the_input_dispatcher();
     virtual std::shared_ptr<input::InputSender>     the_input_sender();
@@ -187,7 +190,7 @@
     virtual std::shared_ptr<graphics::DisplayReport> the_display_report();
     virtual std::shared_ptr<graphics::Cursor> the_cursor();
     virtual std::shared_ptr<graphics::CursorImage> the_default_cursor_image();
-    virtual std::shared_ptr<graphics::CursorImages> the_cursor_images();
+    virtual std::shared_ptr<input::CursorImages> the_cursor_images();
 
     /** @} */
 
@@ -222,6 +225,7 @@
      * internal dependencies of frontend
      *  @{ */
     virtual std::shared_ptr<frontend::ConnectionCreator>      the_connection_creator();
+    virtual std::shared_ptr<frontend::ConnectionCreator>      the_prompt_connection_creator();
     virtual std::shared_ptr<frontend::ConnectorReport>        the_connector_report();
     /** @} */
     /** @} */
@@ -290,6 +294,12 @@
     virtual std::shared_ptr<graphics::GLProgramFactory> the_gl_program_factory();
     virtual std::shared_ptr<input::InputChannelFactory> the_input_channel_factory();
     virtual std::shared_ptr<scene::MediatingDisplayChanger> the_mediating_display_changer();
+    virtual std::shared_ptr<frontend::ProtobufIpcFactory> new_ipc_factory(
+        std::shared_ptr<frontend::SessionAuthorizer> const& session_authorizer);
+
+    // TODO Remove after 0.5.0 is branched: the_ipc_factory() is used by
+    // TODO clients that use the "PrivateProtobuf" but is it now deprecated
+    // TODO and only retained as a migration aid.
     virtual std::shared_ptr<frontend::ProtobufIpcFactory> the_ipc_factory(
         std::shared_ptr<frontend::Shell> const& shell,
         std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator);
@@ -318,6 +328,7 @@
     CachedPtr<droidinput::InputDispatcherPolicyInterface> android_dispatcher_policy;
 
     CachedPtr<frontend::Connector>   connector;
+    CachedPtr<frontend::Connector>   prompt_connector;
 
     CachedPtr<input::InputConfiguration> input_configuration;
 
@@ -331,20 +342,23 @@
     CachedPtr<shell::InputTargeter> input_targeter;
     CachedPtr<input::CursorListener> cursor_listener;
     CachedPtr<graphics::Platform>     graphics_platform;
+    CachedPtr<graphics::NativePlatform>    graphics_native_platform;
     CachedPtr<graphics::BufferInitializer> buffer_initializer;
     CachedPtr<graphics::GraphicBufferAllocator> buffer_allocator;
     CachedPtr<graphics::Display>      display;
     CachedPtr<graphics::Cursor>       cursor;
     CachedPtr<graphics::CursorImage>  default_cursor_image;
-    CachedPtr<graphics::CursorImages> cursor_images;
+    CachedPtr<input::CursorImages> cursor_images;
 
     CachedPtr<frontend::ConnectorReport>   connector_report;
+    // TODO remove after 0.5.0 is branched - c.f. the_ipc_factory()
     CachedPtr<frontend::ProtobufIpcFactory>  ipc_factory;
     CachedPtr<frontend::SessionMediatorReport> session_mediator_report;
     CachedPtr<frontend::MessageProcessorReport> message_processor_report;
     CachedPtr<frontend::SessionAuthorizer> session_authorizer;
     CachedPtr<frontend::EventSink> global_event_sink;
     CachedPtr<frontend::ConnectionCreator> connection_creator;
+    CachedPtr<frontend::ConnectionCreator> prompt_connection_creator;
     CachedPtr<frontend::Screencast> screencast;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
@@ -367,7 +381,8 @@
     CachedPtr<compositor::CompositorReport> compositor_report;
     CachedPtr<logging::Logger> logger;
     CachedPtr<graphics::DisplayReport> display_report;
-    CachedPtr<time::Clock> clock;
+    // static to workaround the singleton clock in AsioMainLoop when running multiple servers
+    static CachedPtr<time::Clock> clock;
     CachedPtr<MainLoop> main_loop;
     CachedPtr<ServerStatusListener> server_status_listener;
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;

=== modified file 'include/server/mir/frontend/fd_sets.h'
--- include/server/mir/frontend/fd_sets.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/frontend/fd_sets.h	2014-07-11 20:27:44 +0000
@@ -20,7 +20,7 @@
 
 #include <vector>
 #include <initializer_list>
-#include <stdint.h>
+#include "mir/fd.h" 
 
 namespace mir
 {
@@ -28,7 +28,7 @@
 {
 namespace detail
 {
-typedef std::initializer_list<std::vector<int32_t>> FdSets;
+typedef std::initializer_list<std::vector<Fd>> FdSets;
 }
 }
 } // namespace mir

=== modified file 'include/server/mir/frontend/session_authorizer.h'
--- include/server/mir/frontend/session_authorizer.h	2014-06-02 17:07:02 +0000
+++ include/server/mir/frontend/session_authorizer.h	2014-07-11 20:27:44 +0000
@@ -36,6 +36,7 @@
     virtual bool connection_is_allowed(SessionCredentials const& creds) = 0;
     virtual bool configure_display_is_allowed(SessionCredentials const& creds) = 0;
     virtual bool screencast_is_allowed(SessionCredentials const& creds) = 0;
+    virtual bool prompt_session_is_allowed(SessionCredentials const&  creds) = 0;
 
 protected:
     SessionAuthorizer() = default;

=== renamed file 'include/server/mir/graphics/cursor_images.h' => 'include/server/mir/input/cursor_images.h'
--- include/server/mir/graphics/cursor_images.h	2014-05-13 20:07:20 +0000
+++ include/server/mir/input/cursor_images.h	2014-07-11 20:27:44 +0000
@@ -17,8 +17,8 @@
  */
 
 
-#ifndef MIR_GRAPHICS_CURSOR_LOADER_H_
-#define MIR_GRAPHICS_CURSOR_LOADER_H_
+#ifndef MIR_INPUT_CURSOR_IMAGES_H_
+#define MIR_INPUT_CURSOR_IMAGES_H_
 
 #include "mir/geometry/size.h"
 
@@ -30,10 +30,13 @@
 namespace graphics
 {
 class CursorImage;
-
-geometry::Size const default_cursor_size{geometry::Width{64}, geometry::Height{64}};
-
-/// CursorImages is used to lookup cursor images.
+}
+
+namespace input
+{
+/// CursorImages is used to lookup cursor images from the system theme.
+geometry::Size const default_cursor_size{geometry::Width{24}, geometry::Height{24}};
+
 class CursorImages
 {
 public:
@@ -41,7 +44,7 @@
 
     /// Looks up the image for a named cursor. Cursor names
     /// follow the XCursor naming conventions.
-    virtual std::shared_ptr<CursorImage> image(std::string const& cursor_name,
+    virtual std::shared_ptr<graphics::CursorImage> image(std::string const& cursor_name,
         geometry::Size const& size) = 0;
 
 protected:
@@ -52,4 +55,4 @@
 }
 }
 
-#endif /* MIR_GRAPHICS_CURSOR_LOADER_H_ */
+#endif /* MIR_INPUT_CURSOR_IMAGES_H_ */

=== modified file 'include/server/mir/server_configuration.h'
--- include/server/mir/server_configuration.h	2014-06-24 12:00:29 +0000
+++ include/server/mir/server_configuration.h	2014-07-11 20:27:44 +0000
@@ -60,6 +60,7 @@
     // TODO most of these interfaces are wider DisplayServer needs...
     // TODO ...some or all of them need narrowing
     virtual std::shared_ptr<frontend::Connector> the_connector() = 0;
+    virtual std::shared_ptr<frontend::Connector> the_prompt_connector() = 0;
     virtual std::shared_ptr<graphics::Display> the_display() = 0;
     virtual std::shared_ptr<compositor::Compositor> the_compositor() = 0;
     virtual std::shared_ptr<input::InputManager> the_input_manager() = 0;

=== added file 'include/shared/mir/basic_observers.h'
--- include/shared/mir/basic_observers.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/basic_observers.h	2014-07-11 20:27:44 +0000
@@ -0,0 +1,122 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_BASIC_OBSERVERS_H_
+#define MIR_BASIC_OBSERVERS_H_
+
+#include "mir/recursive_read_write_mutex.h"
+
+#include <atomic>
+#include <memory>
+
+namespace mir
+{
+template<class Observer>
+class BasicObservers
+{
+protected:
+    void add(std::shared_ptr<Observer> const& observer);
+    void remove(std::shared_ptr<Observer> const& observer);
+    void for_each(std::function<void(std::shared_ptr<Observer> const& observer)> const& f);
+
+private:
+    struct ListItem
+    {
+        ListItem() {}
+        RecursiveReadWriteMutex mutex;
+        std::shared_ptr<Observer> observer;
+        std::atomic<ListItem*> next{nullptr};
+
+        ~ListItem() { delete next.load(); }
+    } head;
+};
+
+template<class Observer>
+void BasicObservers<Observer>::for_each(
+    std::function<void(std::shared_ptr<Observer> const& observer)> const& f)
+{
+    ListItem* current_item = &head;
+
+    while (current_item)
+    {
+        RecursiveReadLock lock{current_item->mutex};
+
+        // We need to take a copy in case we recursively remove during call
+        if (auto const copy_of_observer = current_item->observer) f(copy_of_observer);
+
+        current_item = current_item->next;
+    }
+}
+
+template<class Observer>
+void BasicObservers<Observer>::add(std::shared_ptr<Observer> const& observer)
+{
+    ListItem* current_item = &head;
+
+    do
+    {
+        // Note: we release the read lock to avoid two threads calling add at
+        // the same time mutually blocking the other's upgrade to write lock.
+        {
+            RecursiveReadLock lock{current_item->mutex};
+            if (current_item->observer) continue;
+        }
+
+        RecursiveWriteLock lock{current_item->mutex};
+
+        if (!current_item->observer)
+        {
+            current_item->observer = observer;
+            return;
+        }
+    }
+    while (current_item->next && (current_item = current_item->next));
+
+    // No empty Items so append a new one
+    auto new_item = new ListItem;
+    new_item->observer = observer;
+
+    for (ListItem* expected{nullptr};
+        !current_item->next.compare_exchange_weak(expected, new_item);
+        expected = nullptr)
+    {
+        current_item = expected;
+    }
+}
+
+template<class Observer>
+void BasicObservers<Observer>::remove(std::shared_ptr<Observer> const& observer)
+{
+    ListItem* current_item = &head;
+
+    while (current_item)
+    {
+        RecursiveWriteLock lock{current_item->mutex};
+
+        if (current_item->observer == observer)
+        {
+            current_item->observer.reset();
+            return;
+        }
+
+        current_item = current_item->next;
+    }
+}
+}
+
+#endif /* MIR_BASIC_OBSERVERS_H_ */

=== added file 'include/shared/mir/fd.h'
--- include/shared/mir/fd.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/fd.h	2014-07-11 20:27:44 +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: Kevin DuBois <[e-mail]>
+ */
+#ifndef MIR_FD_H_
+#define MIR_FD_H_
+
+namespace mir
+{
+class Fd
+{
+public:
+    //transfer ownership of the POD-int to the object. The int no longer needs close()ing,
+    //and has the lifetime of the Fd object.
+    explicit Fd(int&& fd);
+    explicit Fd(Fd&&);
+    Fd& operator=(Fd&&);
+    ~Fd() noexcept;
+
+    //bit of a convenient kludge. take care not to close or otherwise destroy the FD.
+    operator int() const;
+
+private:
+    Fd(Fd const&) = delete;
+    Fd& operator=(Fd const&) = delete;
+    int fd;
+};
+} // namespace mir
+
+#endif // MIR_FD_H_

=== modified file 'include/shared/mir/graphics/android/fence.h'
--- include/shared/mir/graphics/android/fence.h	2013-10-15 08:53:10 +0000
+++ include/shared/mir/graphics/android/fence.h	2014-07-11 20:27:44 +0000
@@ -26,6 +26,7 @@
 namespace android
 {
 
+//TODO: (kdub) remove this type in favor of mir::Fd
 typedef int NativeFence;
 
 class Fence
@@ -34,7 +35,7 @@
     virtual ~Fence() = default;
 
     virtual void wait() = 0;
-    virtual void merge_with(NativeFence& merge_fd) = 0;
+    virtual void merge_with(NativeFence&& merge_fd) = 0;
     virtual NativeFence copy_native_handle() const = 0;
 
 protected:

=== modified file 'include/shared/mir/graphics/android/sync_fence.h'
--- include/shared/mir/graphics/android/sync_fence.h	2013-10-15 08:53:10 +0000
+++ include/shared/mir/graphics/android/sync_fence.h	2014-07-11 20:27:44 +0000
@@ -19,6 +19,7 @@
 #define MIR_GRAPHICS_ANDROID_SYNC_FENCE_H_
 
 #include "mir/graphics/android/fence.h"
+#include "mir/fd.h"
 #include <memory>
 
 namespace mir
@@ -48,18 +49,17 @@
 class SyncFence : public Fence
 {
 public:
-    SyncFence(std::shared_ptr<SyncFileOps> const&, int fd);
-    ~SyncFence() noexcept;
+    explicit SyncFence(std::shared_ptr<SyncFileOps> const&, Fd&& fd);
 
     void wait();
-    void merge_with(NativeFence& merge_fd);
+    void merge_with(NativeFence&& merge_fd);
     NativeFence copy_native_handle() const;
 
 private:
     SyncFence(SyncFence const&) = delete;
     SyncFence& operator=(SyncFence const&) = delete;
 
-    int fence_fd;
+    Fd fence_fd;
     std::shared_ptr<SyncFileOps> const ops;
 
     int const infinite_timeout = -1;

=== added file 'include/shared/mir/recursive_read_write_mutex.h'
--- include/shared/mir/recursive_read_write_mutex.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/recursive_read_write_mutex.h	2014-07-11 20:27:44 +0000
@@ -0,0 +1,77 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_RECURSIVE_READ_WRITE_MUTEX_H_
+#define MIR_RECURSIVE_READ_WRITE_MUTEX_H_
+
+#include <condition_variable>
+#include <thread>
+#include <vector>
+
+namespace mir
+{
+/** a recursive read-write mutex.
+ * Note that a write lock can be acquired if no other threads have a read lock.
+ */
+class RecursiveReadWriteMutex
+{
+public:
+    void read_lock();
+
+    void read_unlock();
+
+    void write_lock();
+
+    void write_unlock();
+
+private:
+    std::mutex mutex;
+    std::condition_variable cv;
+    struct ThreadLockCount
+    {
+        ThreadLockCount() : id(), count(0) {}
+        ThreadLockCount(std::thread::id id, unsigned int count) : id(id), count(count) {}
+        std::thread::id id;
+        unsigned int count;
+    };
+    std::vector<ThreadLockCount> read_locking_threads;
+    ThreadLockCount write_locking_thread;
+};
+
+class RecursiveReadLock
+{
+public:
+    explicit RecursiveReadLock(RecursiveReadWriteMutex& mutex) : mutex(mutex) { mutex.read_lock(); }
+    ~RecursiveReadLock() { mutex.read_unlock(); }
+
+private:
+    RecursiveReadWriteMutex& mutex;
+};
+
+class RecursiveWriteLock
+{
+public:
+    explicit RecursiveWriteLock(RecursiveReadWriteMutex& mutex) : mutex(mutex) { mutex.write_lock(); }
+    ~RecursiveWriteLock() { mutex.write_unlock(); }
+
+private:
+    RecursiveReadWriteMutex& mutex;
+};
+}
+
+#endif /* MIR_RECURSIVE_READ_WRITE_MUTEX_H_ */

=== renamed file 'include/test/mir_test_doubles/mock_android_registrar.h' => 'include/test/mir_test_doubles/mock_buffer_registrar.h'
--- include/test/mir_test_doubles/mock_android_registrar.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_buffer_registrar.h	2014-07-11 20:27:44 +0000
@@ -17,11 +17,11 @@
  *   Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_MOCK_ANDROID_REGISTRAR_H_
-#define MIR_TEST_DOUBLES_MOCK_ANDROID_REGISTRAR_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_BUFFER_REGISTRAR_H_
+#define MIR_TEST_DOUBLES_MOCK_BUFFER_REGISTRAR_H_
 
+#include "src/client/android/buffer_registrar.h"
 #include <gmock/gmock.h>
-#include "src/client/android/android_registrar.h"
 
 namespace mir
 {
@@ -33,9 +33,9 @@
 {
 namespace doubles
 {
-struct MockAndroidRegistrar : public client::android::AndroidRegistrar
+struct MockBufferRegistrar : public client::android::BufferRegistrar
 {
-    ~MockAndroidRegistrar() noexcept {}
+    ~MockBufferRegistrar() noexcept {}
     MOCK_CONST_METHOD1(register_buffer,
         std::shared_ptr<const native_handle_t>(std::shared_ptr<MirBufferPackage> const&));
     MOCK_METHOD2(secure_for_cpu, std::shared_ptr<char>(std::shared_ptr<const native_handle_t>, geometry::Rectangle));
@@ -44,4 +44,4 @@
 }
 }
 
-#endif /* MIR_TEST_DOUBLES_MOCK_ANDROID_REGISTRAR_H_ */
+#endif /* MIR_TEST_DOUBLES_MOCK_BUFFER_REGISTRAR_H_ */

=== modified file 'include/test/mir_test_doubles/mock_fence.h'
--- include/test/mir_test_doubles/mock_fence.h	2013-10-10 22:42:31 +0000
+++ include/test/mir_test_doubles/mock_fence.h	2014-07-11 20:27:44 +0000
@@ -32,6 +32,10 @@
 
 struct MockFence : public graphics::android::Fence
 {
+    void merge_with(graphics::android::NativeFence&& fence)
+    {
+        merge_with(fence);
+    }
     MOCK_METHOD0(wait, void());
     MOCK_METHOD1(merge_with, void(graphics::android::NativeFence&));
     MOCK_CONST_METHOD0(copy_native_handle, graphics::android::NativeFence());

=== modified file 'include/test/mir_test_doubles/mock_hwc_device_wrapper.h'
--- include/test/mir_test_doubles/mock_hwc_device_wrapper.h	2014-03-19 21:56:42 +0000
+++ include/test/mir_test_doubles/mock_hwc_device_wrapper.h	2014-07-11 20:27:44 +0000
@@ -34,6 +34,11 @@
 {
     MOCK_CONST_METHOD1(prepare, void(hwc_display_contents_1_t&));
     MOCK_CONST_METHOD1(set, void(hwc_display_contents_1_t&));
+    MOCK_CONST_METHOD1(register_hooks, void(hwc_procs_t*));
+    MOCK_CONST_METHOD0(vsync_signal_on, void());
+    MOCK_CONST_METHOD0(vsync_signal_off, void());
+    MOCK_CONST_METHOD0(display_on, void());
+    MOCK_CONST_METHOD0(display_off, void());
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_client_buffer.h'
--- include/test/mir_test_doubles/null_client_buffer.h	2014-01-21 18:03:46 +0000
+++ include/test/mir_test_doubles/null_client_buffer.h	2014-07-11 20:27:44 +0000
@@ -39,8 +39,9 @@
     geometry::Stride stride() const { return geometry::Stride(); }
     MirPixelFormat pixel_format() const { return mir_pixel_format_invalid; }
     uint32_t age() const { return 0; }
-    void increment_age() { }
+    void increment_age() {}
     void mark_as_submitted() {}
+    void update_from(MirBufferPackage const&) {}
     std::shared_ptr<graphics::NativeBuffer> native_buffer_handle() const
     {
         return nullptr;

=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-07-01 08:40:57 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-07-11 20:27:44 +0000
@@ -55,6 +55,11 @@
         StubRenderable(make_stub_buffer({{},{}}), {{},{}})
     {}
 
+    void set_buffer(std::shared_ptr<graphics::Buffer> const& buffer)
+    {
+        stub_buffer = buffer;
+    }
+
     ID id() const override
     {
         return this;
@@ -103,7 +108,7 @@
 
     glm::mat4 trans;
     geometry::Rectangle const rect;
-    std::shared_ptr<graphics::Buffer> const stub_buffer;
+    std::shared_ptr<graphics::Buffer> stub_buffer;
 };
 
 struct StubTransformedRenderable : public StubRenderable

=== modified file 'include/test/mir_test_doubles/stub_session_authorizer.h'
--- include/test/mir_test_doubles/stub_session_authorizer.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test_doubles/stub_session_authorizer.h	2014-07-11 20:27:44 +0000
@@ -30,15 +30,19 @@
 
 class StubSessionAuthorizer : public frontend::SessionAuthorizer
 {
-    bool connection_is_allowed(mir::frontend::SessionCredentials const&)
-    {
-        return true;
-    }
-    bool configure_display_is_allowed(mir::frontend::SessionCredentials const&)
-    {
-        return true;
-    }
-    bool screencast_is_allowed(mir::frontend::SessionCredentials const&)
+    bool connection_is_allowed(mir::frontend::SessionCredentials const&) override
+    {
+        return true;
+    }
+    bool configure_display_is_allowed(mir::frontend::SessionCredentials const&) override
+    {
+        return true;
+    }
+    bool screencast_is_allowed(mir::frontend::SessionCredentials const&) override
+    {
+        return true;
+    }
+    bool prompt_session_is_allowed(mir::frontend::SessionCredentials const&) override
     {
         return true;
     }

=== modified file 'include/test/mir_test_framework/in_process_server.h'
--- include/test/mir_test_framework/in_process_server.h	2014-06-23 15:57:55 +0000
+++ include/test/mir_test_framework/in_process_server.h	2014-07-11 20:27:44 +0000
@@ -38,6 +38,9 @@
 
     /// \return a connection string for a new client to connect to the server
     using ServerRunner::new_connection;
+
+    /// \return a connection string for a new client to connect to the prompt server
+    using ServerRunner::new_prompt_connection;
 };
 }
 

=== modified file 'include/test/mir_test_framework/server_runner.h'
--- include/test/mir_test_framework/server_runner.h	2014-06-10 12:28:03 +0000
+++ include/test/mir_test_framework/server_runner.h	2014-07-11 20:27:44 +0000
@@ -47,6 +47,9 @@
     /// \return a connection string for a new client to connect to the server
     std::string new_connection();
 
+    /// \return a connection string for a new client to connect to the prompt server
+    std::string new_prompt_connection();
+
 private:
     mir::DisplayServer* start_mir_server();
     virtual mir::DefaultServerConfiguration& server_config() = 0;

=== modified file 'src/client/android/CMakeLists.txt'
--- src/client/android/CMakeLists.txt	2014-06-26 19:16:29 +0000
+++ src/client/android/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -6,7 +6,7 @@
 
   buffer.cpp
   android_client_buffer_factory.cpp
-  android_registrar.cpp
+  gralloc_registrar.cpp
   android_client_platform.cpp
   client_platform_factory.cpp
   client_surface_interpreter.cpp

=== modified file 'src/client/android/android_client_buffer_factory.cpp'
--- src/client/android/android_client_buffer_factory.cpp	2014-06-26 19:16:29 +0000
+++ src/client/android/android_client_buffer_factory.cpp	2014-07-11 20:27:44 +0000
@@ -18,14 +18,16 @@
  */
 
 #include "android_client_buffer_factory.h"
+#include "buffer_registrar.h"
 #include "buffer.h"
 
 namespace mcl=mir::client;
 namespace mcla=mir::client::android;
 namespace geom=mir::geometry;
 
-mcla::AndroidClientBufferFactory::AndroidClientBufferFactory(std::shared_ptr<AndroidRegistrar> const& buffer_registrar)
- : registrar(buffer_registrar)
+mcla::AndroidClientBufferFactory::AndroidClientBufferFactory(
+    std::shared_ptr<BufferRegistrar> const& buffer_registrar) :
+    registrar(buffer_registrar)
 {
 }
 

=== modified file 'src/client/android/android_client_buffer_factory.h'
--- src/client/android/android_client_buffer_factory.h	2014-03-06 06:05:17 +0000
+++ src/client/android/android_client_buffer_factory.h	2014-07-11 20:27:44 +0000
@@ -33,20 +33,20 @@
 namespace client
 {
 class ClientBuffer;
-
 namespace android
 {
-class AndroidRegistrar;
-
+class BufferRegistrar;
 class AndroidClientBufferFactory : public ClientBufferFactory
 {
 public:
-    explicit AndroidClientBufferFactory(std::shared_ptr<AndroidRegistrar> const&);
-
-    virtual std::shared_ptr<ClientBuffer> create_buffer(std::shared_ptr<MirBufferPackage> const& package,
-                                                        geometry::Size size, MirPixelFormat pf);
+    explicit AndroidClientBufferFactory(
+        std::shared_ptr<BufferRegistrar> const& registrar);
+    std::shared_ptr<ClientBuffer> create_buffer(
+        std::shared_ptr<MirBufferPackage> const& package,
+        geometry::Size size,
+        MirPixelFormat pf) override;
 private:
-    std::shared_ptr<AndroidRegistrar> registrar;
+    std::shared_ptr<BufferRegistrar> const registrar;
 };
 
 }

=== modified file 'src/client/android/android_client_platform.cpp'
--- src/client/android/android_client_platform.cpp	2014-03-06 06:05:17 +0000
+++ src/client/android/android_client_platform.cpp	2014-07-11 20:27:44 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/graphics/android/mir_native_window.h"
 #include "android_client_platform.h"
-#include "android_registrar_gralloc.h"
+#include "gralloc_registrar.h"
 #include "android_client_buffer_factory.h"
 #include "client_surface_interpreter.h"
 #include "../mir_connection.h"
@@ -56,7 +56,7 @@
     /* we use an empty deleter because hw_get_module does not give us the ownership of the ptr */
     EmptyDeleter empty_del;
     auto gralloc_dev = std::shared_ptr<gralloc_module_t>(gr_dev, empty_del);
-    auto registrar = std::make_shared<mcla::AndroidRegistrarGralloc>(gralloc_dev);
+    auto registrar = std::make_shared<mcla::GrallocRegistrar>(gralloc_dev);
     return std::make_shared<mcla::AndroidClientBufferFactory>(registrar);
 }
 

=== modified file 'src/client/android/buffer.cpp'
--- src/client/android/buffer.cpp	2014-06-26 19:16:29 +0000
+++ src/client/android/buffer.cpp	2014-07-11 20:27:44 +0000
@@ -19,6 +19,7 @@
 #include "mir/graphics/android/android_native_buffer.h"
 #include "mir/graphics/android/sync_fence.h"
 #include "mir_toolkit/mir_client_library.h"
+#include "buffer_registrar.h"
 #include "buffer.h"
 #include <hardware/gralloc.h>
 
@@ -28,7 +29,7 @@
 namespace mga=mir::graphics::android;
 
 mcla::Buffer::Buffer(
-    std::shared_ptr<AndroidRegistrar> const& registrar,
+    std::shared_ptr<BufferRegistrar> const& registrar,
     std::shared_ptr<const native_handle_t> const& handle,
     geom::Size size,
     MirPixelFormat pf,
@@ -40,7 +41,7 @@
     buffer_size(size)
 {
     auto ops = std::make_shared<mga::RealSyncFileOps>();
-    auto fence = std::make_shared<mga::SyncFence>(ops, -1);
+    auto fence = std::make_shared<mga::SyncFence>(ops, mir::Fd(-1));
     auto anwb = std::shared_ptr<mga::RefCountedNativeBuffer>(
         new mga::RefCountedNativeBuffer(handle),
         [](mga::RefCountedNativeBuffer* buffer)
@@ -96,3 +97,8 @@
 {
     return native_window_buffer;
 }
+
+void mcla::Buffer::update_from(MirBufferPackage const& update_package)
+{
+    (void) update_package;
+}

=== modified file 'src/client/android/buffer.h'
--- src/client/android/buffer.h	2014-06-26 19:16:29 +0000
+++ src/client/android/buffer.h	2014-07-11 20:27:44 +0000
@@ -22,7 +22,6 @@
 
 #include "mir/graphics/android/android_native_buffer.h"
 #include "../aging_buffer.h"
-#include "android_registrar.h"
 
 #include <system/window.h>
 #include <memory>
@@ -34,11 +33,12 @@
 namespace android
 {
 
+class BufferRegistrar;
 class Buffer : public AgingBuffer
 {
 public:
     Buffer(
-        std::shared_ptr<AndroidRegistrar> const&,
+        std::shared_ptr<BufferRegistrar> const&,
         std::shared_ptr<const native_handle_t> const&,
         geometry::Size size,
         MirPixelFormat pf,
@@ -50,13 +50,14 @@
     geometry::Stride stride() const;
     MirPixelFormat pixel_format() const;
     std::shared_ptr<mir::graphics::NativeBuffer> native_buffer_handle() const;
+    void update_from(MirBufferPackage const& update_package);
 
     Buffer(const Buffer&) = delete;
     Buffer& operator=(const Buffer&) = delete;
 private:
     void pack_native_window_buffer();
 
-    std::shared_ptr<AndroidRegistrar> buffer_registrar;
+    std::shared_ptr<BufferRegistrar> buffer_registrar;
     std::shared_ptr<graphics::android::AndroidNativeBuffer> native_window_buffer;
     std::shared_ptr<const native_handle_t> native_handle;
     const MirPixelFormat buffer_pf;

=== renamed file 'src/client/android/android_registrar.h' => 'src/client/android/buffer_registrar.h'
--- src/client/android/android_registrar.h	2013-06-21 22:14:10 +0000
+++ src/client/android/buffer_registrar.h	2014-07-11 20:27:44 +0000
@@ -17,14 +17,14 @@
  *   Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_CLIENT_ANDROID_ANDROID_REGISTRAR_H_
-#define MIR_CLIENT_ANDROID_ANDROID_REGISTRAR_H_
+#ifndef MIR_CLIENT_ANDROID_BUFFER_REGISTRAR_H_
+#define MIR_CLIENT_ANDROID_BUFFER_REGISTRAR_H_
 
 #include <mir_toolkit/mir_native_buffer.h>
 #include "mir/geometry/rectangle.h"
 #include <cutils/native_handle.h>
-
 #include <memory>
+
 namespace mir
 {
 namespace client
@@ -33,16 +33,20 @@
 
 namespace android
 {
-class AndroidRegistrar
+class BufferRegistrar
 {
 public:
-    virtual ~AndroidRegistrar() = default;
+    virtual ~BufferRegistrar() = default;
     virtual std::shared_ptr<const native_handle_t> register_buffer(
         std::shared_ptr<MirBufferPackage> const& package) const = 0;
     virtual std::shared_ptr<char> secure_for_cpu(std::shared_ptr<const native_handle_t> handle, const geometry::Rectangle) = 0;
+protected:
+    BufferRegistrar() = default;
+    BufferRegistrar(BufferRegistrar const&) = delete;
+    BufferRegistrar& operator=(BufferRegistrar const&) = delete;
 };
 
 }
 }
 }
-#endif /* MIR_CLIENT_ANDROID_REGISTRAR_H_ */
+#endif /* MIR_CLIENT_ANDROID_BUFFER_REGISTRAR_H_ */

=== modified file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	2014-05-20 03:37:18 +0000
+++ src/client/android/client_surface_interpreter.cpp	2014-07-11 20:27:44 +0000
@@ -46,7 +46,7 @@
 void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*, int fence_fd)
 {
     //TODO: pass fence to server instead of waiting here
-    mga::SyncFence sync_fence(sync_ops, fence_fd);
+    mga::SyncFence sync_fence(sync_ops, mir::Fd(std::move(fence_fd)));
     sync_fence.wait();
 
     surface.request_and_wait_for_next_buffer();

=== renamed file 'src/client/android/android_registrar.cpp' => 'src/client/android/gralloc_registrar.cpp'
--- src/client/android/android_registrar.cpp	2014-03-06 06:05:17 +0000
+++ src/client/android/gralloc_registrar.cpp	2014-07-11 20:27:44 +0000
@@ -16,7 +16,7 @@
  * Authored by: Kevin DuBois<[e-mail]>
  */
 
-#include "android_registrar_gralloc.h"
+#include "gralloc_registrar.h"
 #include "../client_buffer.h"
 
 #include <boost/throw_exception.hpp>
@@ -66,12 +66,12 @@
 };
 }
 
-mcla::AndroidRegistrarGralloc::AndroidRegistrarGralloc(const std::shared_ptr<const gralloc_module_t>& gr_module)
+mcla::GrallocRegistrar::GrallocRegistrar(const std::shared_ptr<const gralloc_module_t>& gr_module)
 : gralloc_module(gr_module)
 {
 }
 
-std::shared_ptr<const native_handle_t> mcla::AndroidRegistrarGralloc::register_buffer(
+std::shared_ptr<const native_handle_t> mcla::GrallocRegistrar::register_buffer(
     std::shared_ptr<MirBufferPackage> const& package) const
 {
     int native_handle_header_size = sizeof(native_handle_t);
@@ -102,7 +102,9 @@
     return std::shared_ptr<const native_handle_t>(handle, del);
 }
 
-std::shared_ptr<char> mcla::AndroidRegistrarGralloc::secure_for_cpu(std::shared_ptr<const native_handle_t> handle, const geometry::Rectangle rect)
+std::shared_ptr<char> mcla::GrallocRegistrar::secure_for_cpu(
+    std::shared_ptr<const native_handle_t> handle,
+    const geometry::Rectangle rect)
 {
     char* vaddr;
     int usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;

=== renamed file 'src/client/android/android_registrar_gralloc.h' => 'src/client/android/gralloc_registrar.h'
--- src/client/android/android_registrar_gralloc.h	2014-03-06 06:05:17 +0000
+++ src/client/android/gralloc_registrar.h	2014-07-11 20:27:44 +0000
@@ -17,11 +17,11 @@
  *   Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_CLIENT_ANDROID_ANDROID_REGISTRAR_GRALLOC_H_
-#define MIR_CLIENT_ANDROID_ANDROID_REGISTRAR_GRALLOC_H_
+#ifndef MIR_CLIENT_ANDROID_GRALLOC_REGISTRAR_H_
+#define MIR_CLIENT_ANDROID_GRALLOC_REGISTRAR_H_
 
 #include "mir_toolkit/common.h"
-#include "android_registrar.h"
+#include "buffer_registrar.h"
 #include <hardware/gralloc.h>
 
 namespace mir
@@ -31,10 +31,10 @@
 namespace android
 {
 
-class AndroidRegistrarGralloc : public AndroidRegistrar
+class GrallocRegistrar : public BufferRegistrar
 {
 public:
-    AndroidRegistrarGralloc(const std::shared_ptr<const gralloc_module_t>& gralloc_dev);
+    GrallocRegistrar(const std::shared_ptr<const gralloc_module_t>& gralloc_dev);
 
     std::shared_ptr<const native_handle_t> register_buffer(
         std::shared_ptr<MirBufferPackage> const& package) const;
@@ -47,4 +47,4 @@
 }
 }
 }
-#endif /* MIR_CLIENT_ANDROID_ANDROID_REGISTRAR_GRALLOC_H_ */
+#endif /* MIR_CLIENT_ANDROID_GRALLOC_REGISTRAR_H_ */

=== modified file 'src/client/client_buffer.h'
--- src/client/client_buffer.h	2014-03-06 06:05:17 +0000
+++ src/client/client_buffer.h	2014-07-11 20:27:44 +0000
@@ -62,6 +62,7 @@
     virtual void increment_age() = 0;
     virtual void mark_as_submitted() = 0;
     virtual std::shared_ptr<graphics::NativeBuffer> native_buffer_handle() const = 0;
+    virtual void update_from(MirBufferPackage const& update_package) = 0;
 
 protected:
     ClientBuffer() = default;

=== modified file 'src/client/client_buffer_depository.cpp'
--- src/client/client_buffer_depository.cpp	2014-03-06 06:05:17 +0000
+++ src/client/client_buffer_depository.cpp	2014-07-11 20:27:44 +0000
@@ -53,6 +53,7 @@
     }
     else
     {
+        existing_buffer_id_pair->second->update_from(*package);
         buffers.push_front(*existing_buffer_id_pair);
         buffers.erase(existing_buffer_id_pair);
     }

=== modified file 'src/client/mesa/client_buffer.cpp'
--- src/client/mesa/client_buffer.cpp	2014-03-06 06:05:17 +0000
+++ src/client/mesa/client_buffer.cpp	2014-07-11 20:27:44 +0000
@@ -131,3 +131,7 @@
     creation_package->age = age();
     return creation_package;
 }
+
+void mclm::ClientBuffer::update_from(MirBufferPackage const&)
+{
+}

=== modified file 'src/client/mesa/client_buffer.h'
--- src/client/mesa/client_buffer.h	2014-03-06 06:05:17 +0000
+++ src/client/mesa/client_buffer.h	2014-07-11 20:27:44 +0000
@@ -50,6 +50,7 @@
     geometry::Stride stride() const;
     MirPixelFormat pixel_format() const;
     std::shared_ptr<MirNativeBuffer> native_buffer_handle() const;
+    void update_from(MirBufferPackage const&);
 
 private:
     std::shared_ptr<BufferFileOps> const buffer_file_ops;

=== modified file 'src/client/mir_prompt_session_api.cpp'
--- src/client/mir_prompt_session_api.cpp	2014-06-13 10:02:22 +0000
+++ src/client/mir_prompt_session_api.cpp	2014-07-11 20:27:44 +0000
@@ -116,3 +116,15 @@
     mir_wait_for(prompt_session->stop(&null_callback, nullptr));
     delete prompt_session;
 }
+
+MirBool mir_prompt_session_is_valid(MirPromptSession *prompt_session)
+{
+    auto const err = prompt_session->get_error_message();
+
+    return MirBool(!*err);
+}
+
+char const *mir_prompt_session_error_message(MirPromptSession *prompt_session)
+{
+    return prompt_session->get_error_message();
+}

=== modified file 'src/platform/graphics/android/android_alloc_adaptor.cpp'
--- src/platform/graphics/android/android_alloc_adaptor.cpp	2014-06-17 18:24:48 +0000
+++ src/platform/graphics/android/android_alloc_adaptor.cpp	2014-07-11 20:27:44 +0000
@@ -72,7 +72,7 @@
     std::shared_ptr<native_handle_t const> handle(buf_handle, del1);
 
     auto ops = std::make_shared<mga::RealSyncFileOps>();
-    auto fence = std::make_shared<mga::SyncFence>(ops, -1);
+    auto fence = std::make_shared<mga::SyncFence>(ops, mir::Fd(-1));
 
     auto anwb = std::shared_ptr<mga::RefCountedNativeBuffer>(
         new mga::RefCountedNativeBuffer(handle),

=== modified file 'src/platform/graphics/android/hwc_common_device.cpp'
--- src/platform/graphics/android/hwc_common_device.cpp	2014-06-16 21:16:14 +0000
+++ src/platform/graphics/android/hwc_common_device.cpp	2014-07-11 20:27:44 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "hwc_common_device.h"
+#include "hwc_wrapper.h"
 #include "hwc_vsync_coordinator.h"
 
 #include <boost/throw_exception.hpp>
@@ -42,8 +43,8 @@
 }
 }
 
-mga::HWCCommonDevice::HWCCommonDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                                      std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
+mga::HWCCommonDevice::HWCCommonDevice(std::shared_ptr<HwcWrapper> const& hwc_device,
+                                      std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : coordinator(coordinator),
       hwc_device(hwc_device),
       current_mode(mir_power_mode_on)
@@ -53,16 +54,23 @@
     callbacks.hooks.hotplug = hotplug_hook;
     callbacks.self = this;
 
-    hwc_device->registerProcs(hwc_device.get(), &callbacks.hooks);
+    hwc_device->register_hooks(&callbacks.hooks);
 
     turn_screen_on();
 }
 
 mga::HWCCommonDevice::~HWCCommonDevice() noexcept
 {
-    std::unique_lock<std::mutex> lg(blanked_mutex);
     if (current_mode == mir_power_mode_on)
-        turn_screen_off();
+    {
+        std::unique_lock<std::mutex> lg(blanked_mutex);
+        try
+        {
+            turn_screen_off();
+        } catch (...)
+        {
+        }
+    }
 }
 
 void mga::HWCCommonDevice::notify_vsync()
@@ -73,7 +81,6 @@
 void mga::HWCCommonDevice::mode(MirPowerMode mode_request)
 {
     std::unique_lock<std::mutex> lg(blanked_mutex);
-    int err = 0;
 
     if ((mode_request == mir_power_mode_suspend) ||
         (mode_request == mir_power_mode_standby))
@@ -84,22 +91,12 @@
     if ((mode_request == mir_power_mode_on) &&
         (current_mode == mir_power_mode_off))
     {
-        err = turn_screen_on();
+        turn_screen_on();
     }
     else if ((mode_request == mir_power_mode_off) &&
              (current_mode == mir_power_mode_on))
     {
-        err = turn_screen_off();
-    }
-
-    if (err)
-    {
-        std::string blanking_status_msg = "Could not " +
-            ((mode_request == mir_power_mode_off) ? std::string("blank") : std::string("unblank")) + " display";
-        BOOST_THROW_EXCEPTION(
-            boost::enable_error_info(
-                std::runtime_error(blanking_status_msg)) <<
-            boost::errinfo_errno(-err));
+        turn_screen_off();
     }
 
     current_mode = mode_request;
@@ -114,18 +111,16 @@
     return std::move(lg);
 }
 
-int mga::HWCCommonDevice::turn_screen_on() const noexcept(true)
+void mga::HWCCommonDevice::turn_screen_on() const
 {
-    if (auto err = hwc_device->blank(hwc_device.get(), HWC_DISPLAY_PRIMARY, 0))
-        return err;
-    return hwc_device->eventControl(hwc_device.get(), 0, HWC_EVENT_VSYNC, 1);
+    hwc_device->display_on();
+    hwc_device->vsync_signal_on();
 }
 
-int mga::HWCCommonDevice::turn_screen_off() const noexcept(true)
+void mga::HWCCommonDevice::turn_screen_off() const
 {
-    if (auto err = hwc_device->eventControl(hwc_device.get(), 0, HWC_EVENT_VSYNC, 0))
-        return err;
-    return hwc_device->blank(hwc_device.get(), HWC_DISPLAY_PRIMARY, 1);
+    hwc_device->vsync_signal_off();
+    hwc_device->display_off();
 }
 
 bool mga::HWCCommonDevice::apply_orientation(MirOrientation) const

=== modified file 'src/platform/graphics/android/hwc_common_device.h'
--- src/platform/graphics/android/hwc_common_device.h	2014-03-26 05:48:59 +0000
+++ src/platform/graphics/android/hwc_common_device.h	2014-07-11 20:27:44 +0000
@@ -33,6 +33,7 @@
 namespace android
 {
 
+class HwcWrapper;
 class HWCVsyncCoordinator;
 class HWCCommonDevice;
 struct HWCCallbacks
@@ -51,19 +52,19 @@
     bool apply_orientation(MirOrientation orientation) const;
 
 protected:
-    HWCCommonDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+    HWCCommonDevice(std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                     std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
 
     std::shared_ptr<HWCVsyncCoordinator> const coordinator;
     std::unique_lock<std::mutex> lock_unblanked();
 
 private:
-    int turn_screen_on() const noexcept(true);
-    int turn_screen_off() const noexcept(true);
+    void turn_screen_on() const;
+    void turn_screen_off() const;
 
     HWCCallbacks callbacks;
 
-    std::shared_ptr<hwc_composer_device_1> const hwc_device;
+    std::shared_ptr<HwcWrapper> const hwc_device;
 
     std::mutex blanked_mutex;
     std::condition_variable blanked_cond;

=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-06-21 02:09:15 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-07-11 20:27:44 +0000
@@ -64,57 +64,46 @@
 }
 }
 
-void mga::HwcDevice::setup_layer_types()
-{
-    auto it = hwc_list.additional_layers_begin();
-    auto const num_additional_layers = std::distance(it, hwc_list.end());
-    switch (num_additional_layers)
-    {
-        case fbtarget_plus_skip_size:
-            it->set_layer_type(mga::LayerType::skip);
-            ++it;
-        case fbtarget_size:
-            it->set_layer_type(mga::LayerType::framebuffer_target);
-        default:
-            break;
-    }
-}
-
-void mga::HwcDevice::set_list_framebuffer(mg::Buffer const& buffer)
-{
-    geom::Rectangle const disp_frame{{0,0}, {buffer.size()}};
-    for(auto it = hwc_list.additional_layers_begin(); it != hwc_list.end(); it++)
-    {
-        //TODO: the functions on mga::Layer should be consolidated
-        it->set_render_parameters(disp_frame, false);
-        it->set_buffer(buffer);
-        it->prepare_for_draw();
-    }
-}
-
-mga::HwcDevice::HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                          std::shared_ptr<HwcWrapper> const& hwc_wrapper,
+mga::HwcDevice::HwcDevice(std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                           std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
                           std::shared_ptr<SyncFileOps> const& sync_ops)
-    : HWCCommonDevice(hwc_device, coordinator),
-      hwc_list{{}, 2},
+    : HWCCommonDevice(hwc_wrapper, coordinator),
+      hwc_list{{}, fbtarget_plus_skip_size},
       hwc_wrapper(hwc_wrapper), 
       sync_ops(sync_ops)
 {
-    setup_layer_types();
 }
 
 void mga::HwcDevice::post_gl(SwappingGLContext const& context)
 {
-    hwc_list.update_list_and_check_if_changed({}, fbtarget_plus_skip_size);
-    setup_layer_types();
+    auto lg = lock_unblanked();
+    hwc_list.update_list({}, fbtarget_plus_skip_size);
+    auto& skip = *hwc_list.additional_layers_begin();
+    auto& fbtarget = *(++hwc_list.additional_layers_begin());
+
+    auto buffer = context.last_rendered_buffer();
+    geom::Rectangle const disp_frame{{0,0}, {buffer->size()}};
+    skip.layer.setup_layer(mga::LayerType::skip, disp_frame, false, *buffer);
+    fbtarget.layer.setup_layer(mga::LayerType::framebuffer_target, disp_frame, false, *buffer);
 
     hwc_wrapper->prepare(*hwc_list.native_list().lock());
 
     context.swap_buffers();
 
-    post(context);
+    buffer = context.last_rendered_buffer();
+    skip.layer.setup_layer(mga::LayerType::skip, disp_frame, false, *buffer);
+    fbtarget.layer.setup_layer(mga::LayerType::framebuffer_target, disp_frame, false, *buffer);
+
+    for(auto& layer : hwc_list)
+        layer.layer.set_acquirefence_from(*buffer);
+
+    hwc_wrapper->set(*hwc_list.native_list().lock());
     onscreen_overlay_buffers.clear();
+
+    for(auto& layer : hwc_list)
+        layer.layer.update_from_releasefence(*buffer);
+
+    mir::Fd retire_fd(hwc_list.retirement_fence());
 }
 
 bool mga::HwcDevice::post_overlays(
@@ -124,40 +113,63 @@
 {
     if (renderable_list_is_hwc_incompatible(renderables))
         return false;
-    if (!hwc_list.update_list_and_check_if_changed(renderables, fbtarget_size))
+
+    hwc_list.update_list(renderables, fbtarget_size);
+
+    bool needs_commit{false};
+    for(auto& layer : hwc_list)
+        needs_commit |= layer.needs_commit;
+    if (!needs_commit)
         return false;
-    setup_layer_types();
+
+    auto lg = lock_unblanked();
+    auto& fbtarget = *hwc_list.additional_layers_begin();
+
+    auto buffer = context.last_rendered_buffer();
+    geom::Rectangle const disp_frame{{0,0}, {buffer->size()}};
+    fbtarget.layer.setup_layer(mga::LayerType::framebuffer_target, disp_frame, false, *buffer);
 
     hwc_wrapper->prepare(*hwc_list.native_list().lock());
 
     mg::RenderableList rejected_renderables;
-
     std::vector<std::shared_ptr<mg::Buffer>> next_onscreen_overlay_buffers;
-    auto layers_it = hwc_list.begin();
+    auto it = hwc_list.begin();
     for(auto const& renderable : renderables)
     {
-        layers_it->prepare_for_draw();
-        if (layers_it->needs_gl_render())
+        if (it->layer.needs_gl_render())
+        {
             rejected_renderables.push_back(renderable);
+        }
         else
+        {
+            if (it->needs_commit)
+                it->layer.set_acquirefence_from(*renderable->buffer());
             next_onscreen_overlay_buffers.push_back(renderable->buffer());
-        layers_it++;
-    }
-
-    list_compositor.render(rejected_renderables, context);
-    post(context);
+        }
+        it++;
+    }
+
+    if (!rejected_renderables.empty())
+    {
+        list_compositor.render(rejected_renderables, context);
+
+        buffer = context.last_rendered_buffer();
+        fbtarget.layer.setup_layer(mga::LayerType::framebuffer_target, disp_frame, false, *buffer);
+        fbtarget.layer.set_acquirefence_from(*buffer);
+    }
+
+    hwc_wrapper->set(*hwc_list.native_list().lock());
     onscreen_overlay_buffers = std::move(next_onscreen_overlay_buffers);
+
+    it = hwc_list.begin();
+    for(auto const& renderable : renderables)
+    {
+        it->layer.update_from_releasefence(*renderable->buffer());
+        it++;
+    }
+    if (!rejected_renderables.empty())
+        fbtarget.layer.update_from_releasefence(*buffer);
+
+    mir::Fd retire_fd(hwc_list.retirement_fence());
     return true;
 }
-
-void mga::HwcDevice::post(SwappingGLContext const& context)
-{
-    auto lg = lock_unblanked();
-    set_list_framebuffer(*context.last_rendered_buffer());
-    hwc_wrapper->set(*hwc_list.native_list().lock());
-
-    for(auto& layer : hwc_list)
-        layer.update_fence_and_release_buffer();
-
-    mga::SyncFence retire_fence(sync_ops, hwc_list.retirement_fence());
-}

=== modified file 'src/platform/graphics/android/hwc_device.h'
--- src/platform/graphics/android/hwc_device.h	2014-06-16 14:47:14 +0000
+++ src/platform/graphics/android/hwc_device.h	2014-07-11 20:27:44 +0000
@@ -41,10 +41,7 @@
 class HwcDevice : public HWCCommonDevice
 {
 public:
-    //TODO: the first two constructor arguments are redundant. eliminate the 1st one when the 2nd
-    //      one can be used by the HWCCommonDevice 
-    HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-              std::shared_ptr<HwcWrapper> const& hwc_wrapper,
+    HwcDevice(std::shared_ptr<HwcWrapper> const& hwc_wrapper,
               std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
               std::shared_ptr<SyncFileOps> const& sync_ops);
 
@@ -55,14 +52,9 @@
         RenderableListCompositor const& list_compositor);
 
 private:
-    void post(SwappingGLContext const& context);
-
     LayerList hwc_list;
     std::vector<std::shared_ptr<Buffer>> onscreen_overlay_buffers;
 
-    void set_list_framebuffer(Buffer const&);
-    void setup_layer_types();
-
     std::shared_ptr<HwcWrapper> const hwc_wrapper;
     std::shared_ptr<SyncFileOps> const sync_ops;
 };

=== modified file 'src/platform/graphics/android/hwc_fb_device.cpp'
--- src/platform/graphics/android/hwc_fb_device.cpp	2014-06-17 18:24:48 +0000
+++ src/platform/graphics/android/hwc_fb_device.cpp	2014-07-11 20:27:44 +0000
@@ -35,20 +35,22 @@
 namespace mga = mir::graphics::android;
 namespace geom = mir::geometry;
 
-mga::HwcFbDevice::HwcFbDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                              std::shared_ptr<HwcWrapper> const& hwc_wrapper,
-                              std::shared_ptr<framebuffer_device_t> const& fb_device,
-                              std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
-    : HWCCommonDevice(hwc_device, coordinator),
-      hwc_wrapper(hwc_wrapper), 
-      fb_device(fb_device),
-      layer_list{{},1}
+mga::HwcFbDevice::HwcFbDevice(
+    std::shared_ptr<HwcWrapper> const& hwc_wrapper,
+    std::shared_ptr<framebuffer_device_t> const& fb_device,
+    std::shared_ptr<HWCVsyncCoordinator> const& coordinator) :
+    HWCCommonDevice(hwc_wrapper, coordinator),
+    hwc_wrapper(hwc_wrapper), 
+    fb_device(fb_device),
+    layer_list{{},1}
 {
-    layer_list.additional_layers_begin()->set_layer_type(mga::LayerType::skip);
 }
 
 void mga::HwcFbDevice::post_gl(SwappingGLContext const& context)
 {
+    auto& buffer = *context.last_rendered_buffer();
+    layer_list.begin()->layer.setup_layer(mga::LayerType::skip, {{0,0},buffer.size()}, false, buffer);
+
     if (auto display_list = layer_list.native_list().lock())
     {
         hwc_wrapper->prepare(*display_list);
@@ -68,8 +70,8 @@
 
     auto lg = lock_unblanked();
 
-    auto const& buffer = context.last_rendered_buffer();
-    auto native_buffer = buffer->native_buffer_handle();
+    buffer = *context.last_rendered_buffer();
+    auto native_buffer = buffer.native_buffer_handle();
     native_buffer->ensure_available_for(mga::BufferAccess::read);
     if (fb_device->post(fb_device.get(), native_buffer->handle()) != 0)
     {

=== modified file 'src/platform/graphics/android/hwc_fb_device.h'
--- src/platform/graphics/android/hwc_fb_device.h	2014-06-16 14:47:14 +0000
+++ src/platform/graphics/android/hwc_fb_device.h	2014-07-11 20:27:44 +0000
@@ -35,8 +35,7 @@
 class HwcFbDevice : public HWCCommonDevice
 {
 public:
-    HwcFbDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                std::shared_ptr<HwcWrapper> const& hwc_wrapper,
+    HwcFbDevice(std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                 std::shared_ptr<framebuffer_device_t> const& fb_device,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
 

=== modified file 'src/platform/graphics/android/hwc_layerlist.cpp'
--- src/platform/graphics/android/hwc_layerlist.cpp	2014-06-04 23:06:47 +0000
+++ src/platform/graphics/android/hwc_layerlist.cpp	2014-07-11 20:27:44 +0000
@@ -51,13 +51,16 @@
 }
 }
 
-bool mga::LayerList::update_list_and_check_if_changed(
-    RenderableList const& renderlist,
-    size_t additional_layers)
+mga::HwcLayerEntry::HwcLayerEntry(HWCLayer && layer, bool needs_commit) :
+    layer(std::move(layer)),
+    needs_commit{needs_commit}
+{
+}
+
+void mga::LayerList::update_list(RenderableList const& renderlist, size_t additional_layers)
 {
     size_t needed_size = renderlist.size() + additional_layers; 
 
-    bool any_buffer_updated = false;
     if ((!hwc_representation) || hwc_representation->numHwLayers != needed_size)
     {
         hwc_representation = generate_hwc_list(needed_size);
@@ -65,21 +68,20 @@
 
     if (layers.size() == needed_size)
     {
-        auto layers_it = layers.begin();
+        auto it = layers.begin();
         for(auto renderable : renderlist)
         {
-            layers_it->set_render_parameters(
-                renderable->screen_position(), renderable->alpha_enabled());
-            layers_it->set_buffer(*renderable->buffer());
-            any_buffer_updated |= layers_it->needs_hwc_commit(); 
-            layers_it->set_layer_type(mga::LayerType::gl_rendered);
-            layers_it++;
+            it->needs_commit = it->layer.setup_layer(
+                mga::LayerType::gl_rendered,
+                renderable->screen_position(),
+                renderable->alpha_enabled(),
+                *renderable->buffer());
+            it++;
         }
     }
     else
     {
-        any_buffer_updated = true;
-        std::list<HWCLayer> new_layers;
+        std::list<HwcLayerEntry> new_layers;
         auto i = 0u;
         for(auto const& renderable : renderlist)
         {
@@ -88,13 +90,13 @@
                     mga::LayerType::gl_rendered,
                     renderable->screen_position(),
                     renderable->alpha_enabled(),
-                    hwc_representation, i++));
-            new_layers.back().set_buffer(*renderable->buffer());
+                    *renderable->buffer(),
+                    hwc_representation, i++), true);
         }
 
         for(; i < needed_size; i++)
         {
-            new_layers.emplace_back(mga::HWCLayer(hwc_representation, i));
+            new_layers.emplace_back(mga::HWCLayer(hwc_representation, i), false);
         }
         layers = std::move(new_layers);
     }
@@ -108,21 +110,19 @@
         first_additional_layer = layers.begin();
         std::advance(first_additional_layer, renderlist.size());
     }
-
-    return any_buffer_updated;
 }
 
-std::list<mga::HWCLayer>::iterator mga::LayerList::begin()
+std::list<mga::HwcLayerEntry>::iterator mga::LayerList::begin()
 {
     return layers.begin(); 
 }
 
-std::list<mga::HWCLayer>::iterator mga::LayerList::additional_layers_begin()
+std::list<mga::HwcLayerEntry>::iterator mga::LayerList::additional_layers_begin()
 {
     return first_additional_layer;
 }
 
-std::list<mga::HWCLayer>::iterator mga::LayerList::end()
+std::list<mga::HwcLayerEntry>::iterator mga::LayerList::end()
 {
     return layers.end(); 
 }
@@ -141,6 +141,6 @@
     RenderableList const& renderlist,
     size_t additional_layers)
 {
-    update_list_and_check_if_changed(renderlist, additional_layers);
+    update_list(renderlist, additional_layers);
 }
 

=== modified file 'src/platform/graphics/android/hwc_layerlist.h'
--- src/platform/graphics/android/hwc_layerlist.h	2014-03-26 05:48:59 +0000
+++ src/platform/graphics/android/hwc_layerlist.h	2014-07-11 20:27:44 +0000
@@ -39,6 +39,13 @@
 namespace android
 {
 
+struct HwcLayerEntry
+{
+    HwcLayerEntry(HWCLayer && layer, bool needs_commit);
+    HWCLayer layer;
+    bool needs_commit;
+};
+
 /* this is a partitioned list. renderlist makes up the first renderlist.size() elements
    of the list, and there are additional_layers added to the end. 
    std::distance(begin(), additional_layers_begin()) == renderlist.size() 
@@ -49,13 +56,11 @@
 {
 public:
     LayerList(RenderableList const& renderlist, size_t additional_layers);
-    bool update_list_and_check_if_changed(
-        RenderableList const& renderlist,
-        size_t additional_layers);
+    void update_list(RenderableList const& renderlist, size_t additional_layers);
 
-    std::list<HWCLayer>::iterator begin();
-    std::list<HWCLayer>::iterator additional_layers_begin();
-    std::list<HWCLayer>::iterator end();
+    std::list<HwcLayerEntry>::iterator begin();
+    std::list<HwcLayerEntry>::iterator additional_layers_begin();
+    std::list<HwcLayerEntry>::iterator end();
 
     std::weak_ptr<hwc_display_contents_1_t> native_list();
     NativeFence retirement_fence();
@@ -63,9 +68,9 @@
     LayerList& operator=(LayerList const&) = delete;
     LayerList(LayerList const&) = delete;
 
-    std::list<HWCLayer> layers;
+    std::list<HwcLayerEntry> layers;
     std::shared_ptr<hwc_display_contents_1_t> hwc_representation;
-    std::list<HWCLayer>::iterator first_additional_layer;
+    std::list<HwcLayerEntry>::iterator first_additional_layer;
 };
 
 }

=== modified file 'src/platform/graphics/android/hwc_layers.cpp'
--- src/platform/graphics/android/hwc_layers.cpp	2014-06-21 02:09:15 +0000
+++ src/platform/graphics/android/hwc_layers.cpp	2014-07-11 20:27:44 +0000
@@ -55,8 +55,7 @@
 
 mga::HWCLayer::HWCLayer(std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index)
     : hwc_layer(&list->hwLayers[layer_index]),
-      hwc_list(list),
-      associated_buffer(nullptr) //todo: take this as a constructor param 
+      hwc_list(list)
 {
     memset(hwc_layer, 0, sizeof(hwc_layer_1_t));
     memset(&visible_rect, 0, sizeof(hwc_rect_t));
@@ -74,34 +73,40 @@
 
 mga::HWCLayer::HWCLayer(
     LayerType type,
-    geometry::Rectangle position,
+    geometry::Rectangle const& position,
     bool alpha_enabled,
+    Buffer const& buffer,
     std::shared_ptr<hwc_display_contents_1_t> list,
     size_t layer_index)
      : HWCLayer(list, layer_index)
 {
-    set_layer_type(type);
-    set_render_parameters(position, alpha_enabled);
+    setup_layer(type, position, alpha_enabled, buffer);
 }
 
 bool mga::HWCLayer::needs_gl_render() const
 {
-    return ((hwc_layer->compositionType == HWC_FRAMEBUFFER) || (hwc_layer->flags == HWC_SKIP_LAYER));
+    return (hwc_layer->compositionType == HWC_FRAMEBUFFER);
 }
 
-void mga::HWCLayer::update_fence_and_release_buffer()
+void mga::HWCLayer::update_from_releasefence(mg::Buffer const& buffer)
 {
     if (hwc_layer->compositionType != HWC_FRAMEBUFFER)
     { 
-        associated_buffer->update_usage(hwc_layer->releaseFenceFd, mga::BufferAccess::read);
+        auto const& native_buffer = buffer.native_buffer_handle();
+        native_buffer->update_usage(hwc_layer->releaseFenceFd, mga::BufferAccess::read);
         hwc_layer->releaseFenceFd = -1;
         hwc_layer->acquireFenceFd = -1;
-        associated_buffer.reset();
     }
 }
 
-void mga::HWCLayer::set_layer_type(LayerType type)
+bool mga::HWCLayer::setup_layer(
+    LayerType type,
+    geometry::Rectangle const& position,
+    bool alpha_enabled,
+    Buffer const& buffer)
 {
+    bool needs_commit = needs_gl_render();
+
     hwc_layer->flags = 0;
     switch(type)
     {
@@ -122,10 +127,7 @@
         default:
             BOOST_THROW_EXCEPTION(std::logic_error("invalid layer type"));
     }
-}
 
-void mga::HWCLayer::set_render_parameters(geometry::Rectangle position, bool alpha_enabled)
-{
     if (alpha_enabled)
         hwc_layer->blending = HWC_BLENDING_PREMULT;
     else
@@ -141,45 +143,31 @@
         position.bottom_right().x.as_int(),
         position.bottom_right().y.as_int()
     };
-
-    visible_rect = hwc_layer->displayFrame;
-}
-
-void mga::HWCLayer::set_buffer(Buffer const& buffer)
-{
-    associated_buffer.reset();
-    associated_buffer = buffer.native_buffer_handle();
-    updated = (hwc_layer->handle != associated_buffer->handle());
-
-    hwc_layer->handle = associated_buffer->handle();
     hwc_layer->sourceCrop = 
     {
         0, 0,
-        associated_buffer->anwb()->width,
-        associated_buffer->anwb()->height
+        buffer.size().width.as_int(),
+        buffer.size().height.as_int()
     };
+
+    visible_rect = hwc_layer->displayFrame;
+
+    auto const& native_buffer = buffer.native_buffer_handle();
+    needs_commit |= (hwc_layer->handle != native_buffer->handle());
+    hwc_layer->handle = native_buffer->handle();
+
+    return needs_commit;
 }
 
-void mga::HWCLayer::prepare_for_draw()
+void mga::HWCLayer::set_acquirefence_from(mg::Buffer const& buffer)
 {
+    hwc_layer->releaseFenceFd = -1;
+    hwc_layer->acquireFenceFd = -1;
     //we shouldn't be copying the FD unless the HWC has marked this as a buffer its interested in.
     //we disregard fences that haven't changed, as the hwc will still own the buffer
-    if (updated && (((hwc_layer->compositionType == HWC_OVERLAY) ||
-        (hwc_layer->compositionType == HWC_FRAMEBUFFER_TARGET))))
-    {
-        hwc_layer->acquireFenceFd = associated_buffer->copy_fence();
-    }
-    //the HWC is not interested in this buffer. we can release the buffer.
-    else if (hwc_layer->compositionType == HWC_FRAMEBUFFER)
-    {
-        hwc_layer->acquireFenceFd = -1;
-        associated_buffer.reset();
-    }
-
-    hwc_layer->releaseFenceFd = -1;
-}
-
-bool mga::HWCLayer::needs_hwc_commit() const
-{
-    return (updated || needs_gl_render());
+    if (!needs_gl_render())
+    {
+        auto const& native_buffer = buffer.native_buffer_handle();
+        hwc_layer->acquireFenceFd = native_buffer->copy_fence();
+    }
 }

=== modified file 'src/platform/graphics/android/hwc_layers.h'
--- src/platform/graphics/android/hwc_layers.h	2014-06-16 21:16:14 +0000
+++ src/platform/graphics/android/hwc_layers.h	2014-07-11 20:27:44 +0000
@@ -50,11 +50,15 @@
 class HWCLayer
 {
 public:
-    HWCLayer(std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index);
-    HWCLayer(LayerType,
-             geometry::Rectangle screen_position,
-             bool alpha_enabled,
-             std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index);
+    HWCLayer(
+        std::shared_ptr<hwc_display_contents_1_t> list,
+        size_t layer_index);
+    HWCLayer(
+        LayerType,
+        geometry::Rectangle const& screen_position,
+        bool alpha_enabled,
+        Buffer const& buffer,
+        std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index);
 
     HWCLayer& operator=(HWCLayer && layer);
     HWCLayer(HWCLayer && layer);
@@ -62,20 +66,18 @@
     HWCLayer& operator=(HWCLayer const& layer) = delete;
     HWCLayer(HWCLayer const& layer) = delete;
     
-    void set_layer_type(LayerType type);
-    void set_render_parameters(geometry::Rectangle screen_position, bool alpha_enabled);
-    void set_buffer(Buffer const& buffer);
-
-    void update_fence_and_release_buffer();
+    bool setup_layer(
+        LayerType type,
+        geometry::Rectangle const& position,
+        bool alpha_enabled,
+        Buffer const& buffer);
     bool needs_gl_render() const;
-    bool needs_hwc_commit() const;
-    void prepare_for_draw();
+    void set_acquirefence_from(Buffer const& buffer);
+    void update_from_releasefence(Buffer const& buffer);
 private:
     hwc_layer_1_t* hwc_layer;
     std::shared_ptr<hwc_display_contents_1_t> hwc_list;
     hwc_rect_t visible_rect;
-    std::shared_ptr<NativeBuffer> associated_buffer;
-    bool updated{false};
 };
 }
 }

=== modified file 'src/platform/graphics/android/hwc_wrapper.h'
--- src/platform/graphics/android/hwc_wrapper.h	2014-03-19 21:56:42 +0000
+++ src/platform/graphics/android/hwc_wrapper.h	2014-07-11 20:27:44 +0000
@@ -27,6 +27,7 @@
 {
 namespace android
 {
+struct HWCCallbacks;
 class HwcWrapper
 {
 public:
@@ -34,6 +35,11 @@
 
     virtual void prepare(hwc_display_contents_1_t&) const = 0;
     virtual void set(hwc_display_contents_1_t&) const = 0;
+    virtual void register_hooks(hwc_procs_t* callbacks) const = 0;
+    virtual void vsync_signal_on() const = 0;
+    virtual void vsync_signal_off() const = 0;
+    virtual void display_on() const = 0;
+    virtual void display_off() const = 0;
 
 protected:
     HwcWrapper() = default;

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.cpp'
--- src/platform/graphics/android/real_hwc_wrapper.cpp	2014-03-26 05:48:59 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.cpp	2014-07-11 20:27:44 +0000
@@ -60,3 +60,48 @@
         BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
     }
 }
+
+void mga::RealHwcWrapper::register_hooks(hwc_procs_t* callbacks) const
+{
+    hwc_device->registerProcs(hwc_device.get(), callbacks);
+}
+
+void mga::RealHwcWrapper::vsync_signal_on() const
+{
+    if (auto rc = hwc_device->eventControl(hwc_device.get(), 0, HWC_EVENT_VSYNC, 1))
+    {
+        std::stringstream ss;
+        ss << "error turning vsync signal on. rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::RealHwcWrapper::vsync_signal_off() const
+{
+    if (auto rc = hwc_device->eventControl(hwc_device.get(), 0, HWC_EVENT_VSYNC, 0))
+    {
+        std::stringstream ss;
+        ss << "error turning vsync signal off. rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::RealHwcWrapper::display_on() const
+{
+    if (auto rc = hwc_device->blank(hwc_device.get(), HWC_DISPLAY_PRIMARY, 0))
+    {
+        std::stringstream ss;
+        ss << "error turning display on. rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::RealHwcWrapper::display_off() const
+{
+    if (auto rc = hwc_device->blank(hwc_device.get(), HWC_DISPLAY_PRIMARY, 1))
+    {
+        std::stringstream ss;
+        ss << "error turning display off. rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.h'
--- src/platform/graphics/android/real_hwc_wrapper.h	2014-03-26 05:48:59 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.h	2014-07-11 20:27:44 +0000
@@ -39,6 +39,11 @@
 
     void prepare(hwc_display_contents_1_t&) const override;
     void set(hwc_display_contents_1_t&) const override;
+    void register_hooks(hwc_procs_t* callbacks) const override;
+    void vsync_signal_on() const override;
+    void vsync_signal_off() const override;
+    void display_on() const override;
+    void display_off() const override;
 private:
     static size_t const num_displays{3}; //primary, external, virtual
     std::shared_ptr<hwc_composer_device_1> const hwc_device;

=== modified file 'src/platform/graphics/android/resource_factory.cpp'
--- src/platform/graphics/android/resource_factory.cpp	2014-06-02 19:36:02 +0000
+++ src/platform/graphics/android/resource_factory.cpp	2014-07-11 20:27:44 +0000
@@ -100,7 +100,7 @@
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto file_ops = std::make_shared<mga::RealSyncFileOps>();
     auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device, logger);
-    return std::make_shared<mga::HwcDevice>(hwc_native_device, wrapper, syncer, file_ops);
+    return std::make_shared<mga::HwcDevice>(wrapper, syncer, file_ops);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_fb_device(
@@ -109,5 +109,5 @@
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device, logger);
-    return std::make_shared<mga::HwcFbDevice>(hwc_native_device, wrapper, fb_native_device, syncer);
+    return std::make_shared<mga::HwcFbDevice>(wrapper, fb_native_device, syncer);
 }

=== modified file 'src/platform/graphics/mesa/cursor.cpp'
--- src/platform/graphics/mesa/cursor.cpp	2014-06-17 22:07:15 +0000
+++ src/platform/graphics/mesa/cursor.cpp	2014-07-11 20:27:44 +0000
@@ -35,8 +35,8 @@
 
 namespace
 {
-int const width = 64;
-int const height = 64;
+int const buffer_width = 64;
+int const buffer_height = 64;
 
 // Transforms a relative position within the display bounds described by \a rect which is rotated with \a orientation
 geom::Displacement transform(geom::Rectangle const& rect, geom::Displacement const& vector, MirOrientation orientation)
@@ -59,8 +59,8 @@
 mgm::Cursor::GBMBOWrapper::GBMBOWrapper(gbm_device* gbm) :
     buffer(gbm_bo_create(
                 gbm,
-                width,
-                height,
+                buffer_width,
+                buffer_height,
                 GBM_FORMAT_ARGB8888,
                 GBM_BO_USE_CURSOR_64X64 | GBM_BO_USE_WRITE))
 {
@@ -82,8 +82,6 @@
         current_configuration(current_configuration)
 {
     show(*initial_image);
-
-    resume();
 }
 
 mgm::Cursor::~Cursor() noexcept
@@ -91,19 +89,9 @@
     hide();
 }
 
-void mgm::Cursor::show(CursorImage const& cursor_image)
+void mgm::Cursor::write_buffer_data_locked(std::lock_guard<std::mutex> const&, void const* data, size_t count)
 {
-    std::lock_guard<std::mutex> lg(guard);
-    visible = true;
-
-    auto const& size = cursor_image.size();
-
-    if (size != geometry::Size{width, height})
-        BOOST_THROW_EXCEPTION(std::logic_error("No support for cursors that aren't 64x64"));
-
-    auto const count = size.width.as_uint32_t() * size.height.as_uint32_t() * sizeof(uint32_t);
-
-    if (auto result = gbm_bo_write(buffer, cursor_image.as_argb_8888(), count))
+    if (auto result = gbm_bo_write(buffer, data, count))
     {
         BOOST_THROW_EXCEPTION(
             ::boost::enable_error_info(std::runtime_error("failed to initialize gbm buffer"))
@@ -111,6 +99,58 @@
     }
 }
 
+void mgm::Cursor::pad_and_write_image_data_locked(std::lock_guard<std::mutex> const& lg, CursorImage const& image)
+{
+    uint32_t const* image_argb = static_cast<uint32_t const*>(image.as_argb_8888());
+    auto image_width = image.size().width.as_uint32_t();
+    auto image_height = image.size().height.as_uint32_t();
+
+    if (image_width > buffer_width || image_height > buffer_height)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error("Image is too big for GBM cursor buffer"));
+    }
+    
+    uint32_t pixels[buffer_width*buffer_height] {};
+    // 'pixels' is initialized to transparent so we just need to copy the initial image
+    //  in to the top left corner.
+    for (unsigned int i = 0; i < image_height; i++)
+    {
+        for (unsigned int j = 0; j < image_width; j++)
+        {
+            pixels[buffer_width*i+j] = image_argb[image_width*i + j];
+        }
+    }
+
+    auto const count = buffer_width * buffer_height * sizeof(uint32_t);
+    write_buffer_data_locked(lg, pixels, count);
+}
+
+void mgm::Cursor::show(CursorImage const& cursor_image)
+{
+    std::lock_guard<std::mutex> lg(guard);
+
+    auto const& size = cursor_image.size();
+
+    if (size != geometry::Size{buffer_width, buffer_height})
+    {
+        pad_and_write_image_data_locked(lg, cursor_image);
+    }
+    else
+    {
+        auto const count = size.width.as_uint32_t() * size.height.as_uint32_t() * sizeof(uint32_t);
+        write_buffer_data_locked(lg, cursor_image.as_argb_8888(), count);
+    }
+    hotspot = cursor_image.hotspot();
+    
+    // The hotspot may have changed so we need to call drmModeSetCursor again if the cursor was already visible.
+    if (visible)
+        place_cursor_at_locked(lg, current_position, ForceState);
+
+    // Writing the data could throw an exception so lets
+    // hold off on setting visible until after we have succeeded.
+    visible = true;
+}
+
 void mgm::Cursor::move_to(geometry::Point position)
 {
     place_cursor_at(position, UpdateState);
@@ -162,6 +202,14 @@
     ForceCursorState force_state)
 {
     std::lock_guard<std::mutex> lg(guard);
+    place_cursor_at_locked(lg, position, force_state);
+}
+
+void mgm::Cursor::place_cursor_at_locked(
+    std::lock_guard<std::mutex> const&,
+    geometry::Point position,
+    ForceCursorState force_state)
+{
 
     current_position = position;
 
@@ -173,10 +221,15 @@
         if (output_rect.contains(position))
         {
             auto dp = transform(output_rect, position - output_rect.top_left, orientation);
-            output.move_cursor({dp.dx.as_int(), dp.dy.as_int()});
+            
+            // It's a little strange that we implement hotspot this way as there is
+            // drmModeSetCursor2 with hotspot support. However it appears to not actually
+            // work on radeon and intel. There also seems to be precedent in weston for
+            // implementing hotspot in this fashion.
+            output.move_cursor(geom::Point{dp.dx.as_int(), dp.dy.as_int()} - hotspot);
             if (force_state || !output.has_cursor()) // TODO - or if orientation had changed - then set buffer..
             {
-                output.set_cursor(buffer);// TODO - select rotated buffer image
+                output.set_cursor(buffer);
             }
         }
         else

=== modified file 'src/platform/graphics/mesa/cursor.h'
--- src/platform/graphics/mesa/cursor.h	2014-06-17 22:07:15 +0000
+++ src/platform/graphics/mesa/cursor.h	2014-07-11 20:27:44 +0000
@@ -21,6 +21,9 @@
 #define MIR_GRAPHICS_MESA_CURSOR_H_
 
 #include "mir/graphics/cursor.h"
+#include "mir/geometry/point.h"
+#include "mir/geometry/displacement.h"
+
 #include "mir_toolkit/common.h"
 
 #include <gbm.h>
@@ -82,11 +85,16 @@
     enum ForceCursorState { UpdateState, ForceState };
     void for_each_used_output(std::function<void(KMSOutput&, geometry::Rectangle const&, MirOrientation orientation)> const& f);
     void place_cursor_at(geometry::Point position, ForceCursorState force_state);
+    void place_cursor_at_locked(std::lock_guard<std::mutex> const&, geometry::Point position, ForceCursorState force_state);
+    void write_buffer_data_locked(std::lock_guard<std::mutex> const&, void const* data, size_t count);
+    void pad_and_write_image_data_locked(std::lock_guard<std::mutex> const&, CursorImage const& image);
     
     std::mutex guard;
 
     KMSOutputContainer& output_container;
     geometry::Point current_position;
+    geometry::Displacement hotspot;
+
     bool visible;
 
     struct GBMBOWrapper

=== modified file 'src/platform/graphics/mesa/display_buffer.cpp'
--- src/platform/graphics/mesa/display_buffer.cpp	2014-06-10 14:40:23 +0000
+++ src/platform/graphics/mesa/display_buffer.cpp	2014-07-11 20:27:44 +0000
@@ -303,7 +303,7 @@
          * the next frame, but not for bypass frames. Deferring the flip of
          * bypass frames would increase the time we held
          * last_flipped_bypass_buf unacceptably, resulting in client stuttering
-         * unless we allocate quad-buffers (which I'm trying to avoid).
+         * unless we allocate more buffers (which I'm trying to avoid).
          * Also, bypass does not need the deferred page flip because it has
          * no compositing/rendering step for which to save time for.
          */

=== modified file 'src/platform/options/default_configuration.cpp'
--- src/platform/options/default_configuration.cpp	2014-04-15 14:47:19 +0000
+++ src/platform/options/default_configuration.cpp	2014-07-11 20:27:44 +0000
@@ -26,6 +26,7 @@
 namespace mo = mir::options;
 
 char const* const mo::server_socket_opt           = "file,f";
+char const* const mo::prompt_socket_opt           = "prompt-file,p";
 char const* const mo::no_server_socket_opt        = "no-file";
 char const* const mo::enable_input_opt            = "enable-input,i";
 char const* const mo::session_mediator_report_opt = "session-mediator-report";
@@ -77,6 +78,7 @@
         (server_socket_opt, po::value<std::string>()->default_value(::mir::default_server_socket),
             "Socket filename [string:default=$XDG_RUNTIME_DIR/mir_socket or /tmp/mir_socket]")
         (no_server_socket_opt, "Do not provide a socket filename for client connections")
+        (prompt_socket_opt, "Provide a \"..._trusted\" filename for prompt helper connections")
         (platform_graphics_lib, po::value<std::string>()->default_value(default_platform_graphics_lib),
             "Library to use for platform graphics support")
         (enable_input_opt, po::value<bool>()->default_value(enable_input_default),

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-06-25 07:27:23 +0000
+++ src/server/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -30,6 +30,7 @@
   display_server.cpp
   default_server_configuration.cpp
   asio_main_loop.cpp
+  default_emergency_cleanup.cpp
 )
 
 set(MIRSERVER_LINKAGE SHARED)
@@ -47,9 +48,10 @@
   mirsharedinput
   mirsharedgeometry
   mirsharedlogging
+  mirsharedfd
   mirsharedenv
   mirsharedsharedlibrary
-  mirsharedthreadname
+  mirsharedthread
   mirshell
   mirscene
   mirtime
@@ -65,6 +67,7 @@
   mirplatform
   mirclient
   3rd_party
+  xcursorloader
   ${EGL_LDFLAGS} ${EGL_LIBRARIES}
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
   ${UDEV_LDFLAGS} ${UDEV_LIBRARIES}

=== modified file 'src/server/asio_main_loop.cpp'
--- src/server/asio_main_loop.cpp	2014-06-27 07:07:35 +0000
+++ src/server/asio_main_loop.cpp	2014-07-11 20:27:44 +0000
@@ -352,7 +352,9 @@
         {
         }
 
-        std::recursive_mutex m;
+        std::mutex m;
+        int callbacks_running = 0;
+        std::condition_variable callback_done;
         std::function<void(void)> const callback;
         State state;
     };
@@ -381,7 +383,12 @@
                 if (data->state == mir::time::Alarm::pending)
                 {
                     data->state = mir::time::Alarm::triggered;
+                    ++data->callbacks_running;
+                    lock.unlock();
                     data->callback();
+                    lock.lock();
+                    --data->callbacks_running;
+                    data->callback_done.notify_all();
                 }
             }
         }
@@ -420,7 +427,11 @@
 
 bool AlarmImpl::cancel()
 {
-    std::lock_guard<decltype(data->m)> lock(data->m);
+    std::unique_lock<decltype(data->m)> lock(data->m);
+
+    while (data->callbacks_running > 0)
+        data->callback_done.wait(lock);
+
     if (data->state == triggered)
         return false;
 

=== modified file 'src/server/compositor/buffer_queue.cpp'
--- src/server/compositor/buffer_queue.cpp	2014-06-12 15:35:08 +0000
+++ src/server/compositor/buffer_queue.cpp	2014-07-11 20:27:44 +0000
@@ -245,6 +245,10 @@
         current_buffer_users.push_back(user_id);
         current_compositor_buffer = pop(ready_to_composite_queue);
     }
+    else if (current_buffer_users.empty())
+    {   // current_buffer_users and ready_to_composite_queue both empty
+        current_buffer_users.push_back(user_id);
+    }
 
     buffers_sent_to_compositor.push_back(current_compositor_buffer);
 

=== modified file 'src/server/compositor/buffer_queue.h'
--- src/server/compositor/buffer_queue.h	2014-06-12 15:35:08 +0000
+++ src/server/compositor/buffer_queue.h	2014-07-11 20:27:44 +0000
@@ -61,11 +61,11 @@
     int buffers_ready_for_compositor() const override;
     int buffers_free_for_client() const override;
     bool framedropping_allowed() const;
+    bool is_a_current_buffer_user(void const* user_id) const;
 
 private:
     void give_buffer_to_client(graphics::Buffer* buffer,
         std::unique_lock<std::mutex> lock);
-    bool is_a_current_buffer_user(void const* user_id) const;
     void release(graphics::Buffer* buffer,
         std::unique_lock<std::mutex> lock);
     void drop_frame(std::unique_lock<std::mutex> lock);

=== modified file 'src/server/compositor/buffer_stream_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2014-06-09 17:16:32 +0000
+++ src/server/compositor/buffer_stream_factory.cpp	2014-07-11 20:27:44 +0000
@@ -47,7 +47,7 @@
 std::shared_ptr<mc::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
     mg::BufferProperties const& buffer_properties)
 {
-    // Note: Framedropping and bypass both require a minimum 3 buffers
+    // Note: Framedropping requires a minimum 3 buffers
     auto switching_bundle = std::make_shared<mc::BufferQueue>(3, gralloc, buffer_properties, *policy_factory);
     return std::make_shared<mc::BufferStreamSurfaces>(switching_bundle);
 }

=== added file 'src/server/default_emergency_cleanup.cpp'
--- src/server/default_emergency_cleanup.cpp	1970-01-01 00:00:00 +0000
+++ src/server/default_emergency_cleanup.cpp	2014-07-11 20:27:44 +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]>
+ */
+
+#include "default_emergency_cleanup.h"
+
+void mir::DefaultEmergencyCleanup::add(EmergencyCleanupHandler const& handler)
+{
+    std::lock_guard<std::mutex> lock{handlers_mutex};
+
+    last_item()->next.reset(new ListItem{handler, nullptr});
+    ++num_handlers;
+}
+
+void mir::DefaultEmergencyCleanup::operator()() const
+{
+    int handlers_left = num_handlers;
+    ListItem const* item = &head;
+    while (handlers_left-- > 0)
+    {
+        item = item->next.get();
+        item->handler();
+    }
+}
+
+mir::DefaultEmergencyCleanup::ListItem* mir::DefaultEmergencyCleanup::last_item()
+{
+    ListItem* item = &head;
+    while (item->next)
+        item = item->next.get();
+    return item;
+}

=== added file 'src/server/default_emergency_cleanup.h'
--- src/server/default_emergency_cleanup.h	1970-01-01 00:00:00 +0000
+++ src/server/default_emergency_cleanup.h	2014-07-11 20:27:44 +0000
@@ -0,0 +1,53 @@
+/*
+ * 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_DEFAULT_EMERGENCY_CLEANUP_H_
+#define MIR_DEFAULT_EMERGENCY_CLEANUP_H_
+
+#include <mir/emergency_cleanup.h>
+
+#include <memory>
+#include <atomic>
+#include <mutex>
+
+namespace mir
+{
+
+class DefaultEmergencyCleanup : public EmergencyCleanup
+{
+public:
+    void add(EmergencyCleanupHandler const& handler) override;
+    void operator()() const override;
+
+private:
+    struct ListItem
+    {
+        EmergencyCleanupHandler handler;
+        std::unique_ptr<ListItem> next;
+    };
+
+    ListItem* last_item();
+
+    ListItem head;
+    std::atomic<int> num_handlers{0};
+    std::mutex handlers_mutex;
+};
+
+}
+
+#endif

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2014-06-17 22:07:15 +0000
+++ src/server/default_server_configuration.cpp	2014-07-11 20:27:44 +0000
@@ -38,10 +38,7 @@
 #include "mir/geometry/rectangles.h"
 #include "mir/default_configuration.h"
 #include "mir/scene/null_prompt_session_listener.h"
-
-#include <map>
-#include <vector>
-#include <mutex>
+#include "default_emergency_cleanup.h"
 
 namespace mc = mir::compositor;
 namespace geom = mir::geometry;
@@ -139,6 +136,11 @@
         {
             return true;
         }
+
+        bool prompt_session_is_allowed(mf::SessionCredentials const& /* creds */) override
+        {
+            return true;
+        }
     };
     return session_authorizer(
         [&]()
@@ -147,6 +149,8 @@
         });
 }
 
+mir::CachedPtr<mir::time::Clock> mir::DefaultServerConfiguration::clock;
+
 std::shared_ptr<mir::time::Clock> mir::DefaultServerConfiguration::the_clock()
 {
     return clock(
@@ -181,31 +185,6 @@
 
 std::shared_ptr<mir::EmergencyCleanup> mir::DefaultServerConfiguration::the_emergency_cleanup()
 {
-    struct DefaultEmergencyCleanup : public EmergencyCleanup
-    {
-        void add(EmergencyCleanupHandler const& handler) override
-        {
-            std::lock_guard<std::mutex> lock{handlers_mutex};
-            handlers.push_back(handler);
-        }
-
-        void operator()() const override
-        {
-            decltype(handlers) handlers_copy;
-
-            {
-                std::unique_lock<std::mutex> lock{handlers_mutex};
-                handlers_copy = handlers;
-            }
-
-            for (auto const& handler : handlers_copy)
-                handler();
-        }
-
-        mutable std::mutex handlers_mutex;
-        std::vector<EmergencyCleanupHandler> handlers;
-    };
-
     return emergency_cleanup(
         []()
         {

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2014-06-03 11:04:15 +0000
+++ src/server/display_server.cpp	2014-07-11 20:27:44 +0000
@@ -77,6 +77,7 @@
           input_configuration{config.the_input_configuration()},
           compositor{config.the_compositor()},
           connector{config.the_connector()},
+          prompt_connector{config.the_prompt_connector()},
           input_manager{config.the_input_manager()},
           main_loop{config.the_main_loop()},
           server_status_listener{config.the_server_status_listener()},
@@ -112,6 +113,10 @@
                 [this] { compositor->stop(); },
                 [this] { compositor->start(); }};
 
+            TryButRevertIfUnwinding prompt{
+                [this] { prompt_connector->stop(); },
+                [this] { prompt_connector->start(); }};
+
             TryButRevertIfUnwinding comm{
                 [this] { connector->stop(); },
                 [this] { connector->start(); }};
@@ -140,6 +145,10 @@
                 [this] { connector->start(); },
                 [this] { connector->stop(); }};
 
+            TryButRevertIfUnwinding prompt{
+                [this] { prompt_connector->start(); },
+                [this] { prompt_connector->stop(); }};
+
             TryButRevertIfUnwinding display_config_processing{
                 [this] { display_changer->resume_display_config_processing(); },
                 [this] { display_changer->pause_display_config_processing(); }};
@@ -180,6 +189,7 @@
     std::shared_ptr<input::InputConfiguration> const input_configuration;
     std::shared_ptr<mc::Compositor> const compositor;
     std::shared_ptr<mf::Connector> const connector;
+    std::shared_ptr<mf::Connector> const prompt_connector;
     std::shared_ptr<mi::InputManager> const input_manager;
     std::shared_ptr<mir::MainLoop> const main_loop;
     std::shared_ptr<mir::ServerStatusListener> const server_status_listener;
@@ -203,6 +213,7 @@
 void mir::DisplayServer::run()
 {
     p->connector->start();
+    p->prompt_connector->start();
     p->compositor->start();
     p->input_manager->start();
     p->input_dispatcher->start();
@@ -214,6 +225,7 @@
     p->input_dispatcher->stop();
     p->input_manager->stop();
     p->compositor->stop();
+    p->prompt_connector->stop();
     p->connector->stop();
 }
 

=== modified file 'src/server/frontend/CMakeLists.txt'
--- src/server/frontend/CMakeLists.txt	2014-06-02 17:07:02 +0000
+++ src/server/frontend/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -3,7 +3,9 @@
 
   client_buffer_tracker.cpp
   connection_context.cpp
+  no_prompt_shell.cpp
   session_mediator.cpp
+  shell_wrapper.cpp
   protobuf_message_processor.cpp
   protobuf_responder.cpp
   protobuf_buffer_packer.cpp

=== modified file 'src/server/frontend/default_configuration.cpp'
--- src/server/frontend/default_configuration.cpp	2014-06-17 22:07:15 +0000
+++ src/server/frontend/default_configuration.cpp	2014-07-11 20:27:44 +0000
@@ -23,6 +23,7 @@
 #include "published_socket_connector.h"
 
 #include "mir/frontend/protobuf_connection_creator.h"
+#include "mir/frontend/session_authorizer.h"
 #include "mir/options/configuration.h"
 #include "mir/options/option.h"
 
@@ -34,9 +35,10 @@
 {
     return connection_creator([this]
         {
+            auto const session_authorizer = the_session_authorizer();
             return std::make_shared<mf::ProtobufConnectionCreator>(
-                the_ipc_factory(the_frontend_shell(), the_buffer_allocator()),
-                the_session_authorizer(),
+                new_ipc_factory(session_authorizer),
+                session_authorizer,
                 the_message_processor_report());
         });
 }
@@ -68,6 +70,72 @@
         });
 }
 
+std::shared_ptr<mf::ConnectionCreator>
+mir::DefaultServerConfiguration::the_prompt_connection_creator()
+{
+    struct PromptSessionAuthorizer : public mf::SessionAuthorizer
+    {
+        bool connection_is_allowed(mf::SessionCredentials const& /* creds */) override
+        {
+            return true;
+        }
+
+        bool configure_display_is_allowed(mf::SessionCredentials const& /* creds */) override
+        {
+            return true;
+        }
+
+        bool screencast_is_allowed(mf::SessionCredentials const& /* creds */) override
+        {
+            return true;
+        }
+
+        bool prompt_session_is_allowed(mf::SessionCredentials const& /* creds */) override
+        {
+            return true;
+        }
+    };
+
+    return prompt_connection_creator([this]
+        {
+            auto const session_authorizer = std::make_shared<PromptSessionAuthorizer>();
+            return std::make_shared<mf::ProtobufConnectionCreator>(
+                new_ipc_factory(session_authorizer),
+                session_authorizer,
+                the_message_processor_report());
+        });
+}
+
+std::shared_ptr<mf::Connector>
+mir::DefaultServerConfiguration::the_prompt_connector()
+{
+    return prompt_connector(
+        [&,this]() -> std::shared_ptr<mf::Connector>
+        {
+            auto const threads = the_options()->get<int>(options::frontend_threads_opt);
+
+            if (the_options()->is_set(options::prompt_socket_opt))
+            {
+                return std::make_shared<mf::PublishedSocketConnector>(
+                    the_socket_file() + "_trusted",
+                    the_prompt_connection_creator(),
+                    threads,
+                    *the_emergency_cleanup(),
+                    the_connector_report());
+            }
+            else
+            {
+                return std::make_shared<mf::BasicConnector>(
+                    the_prompt_connection_creator(),
+                    threads,
+                    the_connector_report());
+            }
+        });
+}
+
+// TODO Remove after 0.5.0 is branched: the_ipc_factory() is used by
+// TODO clients that use the "PrivateProtobuf" but is it now deprecated
+// TODO and only retained as a migration aid.
 std::shared_ptr<mir::frontend::ProtobufIpcFactory>
 mir::DefaultServerConfiguration::the_ipc_factory(
     std::shared_ptr<mf::Shell> const& shell,
@@ -87,3 +155,18 @@
                 the_cursor_images());
         });
 }
+
+std::shared_ptr<mir::frontend::ProtobufIpcFactory>
+mir::DefaultServerConfiguration::new_ipc_factory(
+    std::shared_ptr<mf::SessionAuthorizer> const& session_authorizer)
+{
+    return std::make_shared<mf::DefaultIpcFactory>(
+        the_frontend_shell(),
+        the_session_mediator_report(),
+        the_graphics_platform(),
+        the_frontend_display_changer(),
+        the_buffer_allocator(),
+        the_screencast(),
+        session_authorizer,
+        the_cursor_images());
+}

=== modified file 'src/server/frontend/default_ipc_factory.cpp'
--- src/server/frontend/default_ipc_factory.cpp	2014-05-14 21:53:39 +0000
+++ src/server/frontend/default_ipc_factory.cpp	2014-07-11 20:27:44 +0000
@@ -18,6 +18,7 @@
 
 #include "default_ipc_factory.h"
 
+#include "no_prompt_shell.h"
 #include "session_mediator.h"
 #include "unauthorized_display_changer.h"
 #include "unauthorized_screencast.h"
@@ -27,6 +28,7 @@
 
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
+namespace mi = mir::input;
 
 mf::DefaultIpcFactory::DefaultIpcFactory(
     std::shared_ptr<Shell> const& shell,
@@ -36,8 +38,9 @@
     std::shared_ptr<mg::GraphicBufferAllocator> const& buffer_allocator,
     std::shared_ptr<Screencast> const& screencast,
     std::shared_ptr<SessionAuthorizer> const& session_authorizer,
-    std::shared_ptr<mg::CursorImages> const& cursor_images) :
+    std::shared_ptr<mi::CursorImages> const& cursor_images) :
     shell(shell),
+    no_prompt_shell(std::make_shared<NoPromptShell>(shell)),
     sm_report(sm_report),
     cache(std::make_shared<ResourceCache>()),
     graphics_platform(graphics_platform),
@@ -75,8 +78,13 @@
         effective_screencast = std::make_shared<UnauthorizedScreencast>();
     }
 
+    auto const allow_prompt_session =
+        session_authorizer->prompt_session_is_allowed(creds);
+
+    auto const effective_shell = allow_prompt_session ? shell : no_prompt_shell;
+
     return make_mediator(
-        shell,
+        effective_shell,
         graphics_platform,
         changer,
         buffer_allocator,
@@ -100,7 +108,7 @@
     std::shared_ptr<EventSink> const& sink,
     std::shared_ptr<Screencast> const& effective_screencast,
     ConnectionContext const& connection_context,
-    std::shared_ptr<mg::CursorImages> const& cursor_images)
+    std::shared_ptr<mi::CursorImages> const& cursor_images)
 {
     return std::make_shared<SessionMediator>(
         shell,

=== modified file 'src/server/frontend/default_ipc_factory.h'
--- src/server/frontend/default_ipc_factory.h	2014-05-14 21:53:39 +0000
+++ src/server/frontend/default_ipc_factory.h	2014-07-11 20:27:44 +0000
@@ -27,6 +27,9 @@
 {
 class Platform;
 class GraphicBufferAllocator;
+}
+namespace input
+{
 class CursorImages;
 }
 
@@ -49,7 +52,7 @@
         std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<Screencast> const& screencast,
         std::shared_ptr<SessionAuthorizer> const& session_authorizer,
-        std::shared_ptr<graphics::CursorImages> const& cursor_images);
+        std::shared_ptr<input::CursorImages> const& cursor_images);
 
     std::shared_ptr<detail::DisplayServer> make_ipc_server(
         SessionCredentials const& creds,
@@ -67,10 +70,11 @@
         std::shared_ptr<EventSink> const& sink,
         std::shared_ptr<Screencast> const& effective_screencast,
         ConnectionContext const& connection_context,
-        std::shared_ptr<graphics::CursorImages> const& cursor_images);
+        std::shared_ptr<input::CursorImages> const& cursor_images);
 
 private:
     std::shared_ptr<Shell> const shell;
+    std::shared_ptr<Shell> const no_prompt_shell;
     std::shared_ptr<SessionMediatorReport> const sm_report;
     std::shared_ptr<ResourceCache> const cache;
     std::shared_ptr<graphics::Platform> const graphics_platform;
@@ -78,7 +82,7 @@
     std::shared_ptr<graphics::GraphicBufferAllocator> const buffer_allocator;
     std::shared_ptr<Screencast> const screencast;
     std::shared_ptr<SessionAuthorizer> const session_authorizer;
-    std::shared_ptr<graphics::CursorImages> const cursor_images;
+    std::shared_ptr<input::CursorImages> const cursor_images;
 };
 }
 }

=== added file 'src/server/frontend/no_prompt_shell.cpp'
--- src/server/frontend/no_prompt_shell.cpp	1970-01-01 00:00:00 +0000
+++ src/server/frontend/no_prompt_shell.cpp	2014-07-11 20:27:44 +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 General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#include "no_prompt_shell.h"
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace mf = mir::frontend;
+
+namespace
+{
+char const* const prompt_sessions_disabled = "Prompt sessions disabled";
+}
+
+std::shared_ptr<mf::PromptSession> mf::NoPromptShell::start_prompt_session_for(
+    std::shared_ptr<Session> const& /*session*/,
+    scene::PromptSessionCreationParameters const& /*params*/)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(prompt_sessions_disabled));
+}
+
+void mf::NoPromptShell::add_prompt_provider_process_for(
+    std::shared_ptr<PromptSession> const& /*prompt_session*/,
+    pid_t /*process_id*/)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(prompt_sessions_disabled));
+}
+
+void mf::NoPromptShell::add_prompt_provider_for(
+    std::shared_ptr<PromptSession> const& /*prompt_session*/,
+    std::shared_ptr<Session> const& /*session*/)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(prompt_sessions_disabled));
+}
+
+void mf::NoPromptShell::stop_prompt_session(
+    std::shared_ptr<PromptSession> const& /*prompt_session*/)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(prompt_sessions_disabled));
+}

=== added file 'src/server/frontend/no_prompt_shell.h'
--- src/server/frontend/no_prompt_shell.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/no_prompt_shell.h	2014-07-11 20:27:44 +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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_NO_PROMPT_SHELL_H_
+#define MIR_FRONTEND_NO_PROMPT_SHELL_H_
+
+#include "shell_wrapper.h"
+
+namespace mir
+{
+namespace frontend
+{
+class NoPromptShell : public ShellWrapper
+{
+public:
+
+    using ShellWrapper::ShellWrapper;
+
+    std::shared_ptr<PromptSession> start_prompt_session_for(
+        std::shared_ptr<Session> const& session,
+        scene::PromptSessionCreationParameters const& params) override;
+
+    void add_prompt_provider_process_for(
+        std::shared_ptr<PromptSession> const& prompt_session,
+        pid_t process_id) override;
+
+    void add_prompt_provider_for(
+        std::shared_ptr<PromptSession> const& prompt_session,
+        std::shared_ptr<Session> const& session) override;
+
+    void stop_prompt_session(
+        std::shared_ptr<PromptSession> const& prompt_session) override;
+};
+}
+}
+
+#endif /* MIR_FRONTEND_NO_PROMPT_SHELL_H_ */

=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
--- src/server/frontend/protobuf_message_processor.cpp	2014-06-11 16:11:32 +0000
+++ src/server/frontend/protobuf_message_processor.cpp	2014-07-11 20:27:44 +0000
@@ -29,9 +29,14 @@
 namespace
 {
 template<class Response>
-std::vector<int32_t> extract_fds_from(Response* response)
+std::vector<mir::Fd> extract_fds_from(Response* response)
 {
-    std::vector<int32_t> fd(response->fd().data(), response->fd().data() + response->fd().size());
+    std::vector<mir::Fd> fd;
+    for(auto i = 0u; i < response->fd().size(); ++i)
+    {
+        int fence = response->fd().data()[i];
+        fd.emplace_back(mir::Fd(std::move(fence)));
+    }
     response->clear_fd();
     response->set_fds_on_side_channel(fd.size());
     return fd;
@@ -151,10 +156,6 @@
         {
             invoke(this, display_server.get(), &DisplayServer::release_surface, invocation);
         }
-        else if ("test_file_descriptors" == invocation.method_name())
-        {
-            invoke(this, display_server.get(), &DisplayServer::test_file_descriptors, invocation);
-        }
         else if ("drm_auth_magic" == invocation.method_name())
         {
             invoke(this, display_server.get(), &DisplayServer::drm_auth_magic, invocation);
@@ -228,8 +229,7 @@
 
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Buffer* response)
 {
-    const auto& fd = extract_fds_from(response);
-    sender->send_response(id, response, {fd});
+    sender->send_response(id, response, {extract_fds_from(response)});
 }
 
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, std::shared_ptr<protobuf::Buffer> response)
@@ -239,35 +239,30 @@
 
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Connection* response)
 {
-    const auto& fd = response->has_platform() ?
-        extract_fds_from(response->mutable_platform()) :
-        std::vector<int32_t>();
-
-    sender->send_response(id, response, {fd});
+    if (response->has_platform())
+        sender->send_response(id, response, {extract_fds_from(response->mutable_platform())});
+    else
+        sender->send_response(id, response, {});
 }
 
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Surface* response)
 {
-    auto const& surface_fd = extract_fds_from(response);
-    const auto& buffer_fd = response->has_buffer() ?
-        extract_fds_from(response->mutable_buffer()) :
-        std::vector<int32_t>();
-
-    sender->send_response(id, response, {surface_fd, buffer_fd});
+    if (response->has_buffer())
+        sender->send_response(id, response, {extract_fds_from(response), extract_fds_from(response->mutable_buffer())});
+    else
+        sender->send_response(id, response, {extract_fds_from(response)});
 }
 
 void mfd::ProtobufMessageProcessor::send_response(
     ::google::protobuf::uint32 id, mir::protobuf::Screencast* response)
 {
-    auto const& buffer_fd = response->has_buffer() ?
-        extract_fds_from(response->mutable_buffer()) :
-        std::vector<int32_t>();
-
-    sender->send_response(id, response, {buffer_fd});
+    if (response->has_buffer())
+        sender->send_response(id, response, {extract_fds_from(response->mutable_buffer())});
+    else
+        sender->send_response(id, response, {});
 }
 
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::SocketFD* response)
 {
-    const auto& fd = extract_fds_from(response);
-    sender->send_response(id, response, {fd});
+    sender->send_response(id, response, {extract_fds_from(response)});
 }

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2014-06-23 02:57:39 +0000
+++ src/server/frontend/session_mediator.cpp	2014-07-11 20:27:44 +0000
@@ -29,7 +29,7 @@
 #include "mir_toolkit/common.h"
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/buffer.h"
-#include "mir/graphics/cursor_images.h"
+#include "mir/input/cursor_images.h"
 #include "mir/compositor/buffer_stream.h"
 #include "mir/geometry/dimensions.h"
 #include "mir/frontend/display_changer.h"
@@ -58,6 +58,7 @@
 namespace mf = mir::frontend;
 namespace mfd=mir::frontend::detail;
 namespace mg = mir::graphics;
+namespace mi = mir::input;
 namespace geom = mir::geometry;
 
 mf::SessionMediator::SessionMediator(
@@ -70,7 +71,7 @@
     std::shared_ptr<ResourceCache> const& resource_cache,
     std::shared_ptr<Screencast> const& screencast,
     ConnectionContext const& connection_context,
-    std::shared_ptr<mg::CursorImages> const& cursor_images) :
+    std::shared_ptr<mi::CursorImages> const& cursor_images) :
     client_pid_(0),
     shell(shell),
     graphics_platform(graphics_platform),
@@ -464,7 +465,7 @@
 
         if (cursor_request->has_name())
         {
-            auto const& image = cursor_images->image(cursor_request->name(), mg::default_cursor_size);
+            auto const& image = cursor_images->image(cursor_request->name(), mi::default_cursor_size);
             surface->set_cursor_image(image);
         }
         else

=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2014-06-23 02:57:39 +0000
+++ src/server/frontend/session_mediator.h	2014-07-11 20:27:44 +0000
@@ -39,6 +39,9 @@
 class Platform;
 class Display;
 class GraphicBufferAllocator;
+}
+namespace input
+{
 class CursorImages;
 }
 
@@ -72,7 +75,7 @@
         std::shared_ptr<ResourceCache> const& resource_cache,
         std::shared_ptr<Screencast> const& screencast,
         ConnectionContext const& connection_context,
-        std::shared_ptr<graphics::CursorImages> const& cursor_images);
+        std::shared_ptr<input::CursorImages> const& cursor_images);
 
     ~SessionMediator() noexcept;
 
@@ -186,7 +189,7 @@
     std::shared_ptr<ResourceCache> const resource_cache;
     std::shared_ptr<Screencast> const screencast;
     ConnectionContext const connection_context;
-    std::shared_ptr<graphics::CursorImages> const cursor_images;
+    std::shared_ptr<input::CursorImages> const cursor_images;
 
     std::unordered_map<SurfaceId,graphics::Buffer*> client_buffer_resource;
     std::unordered_map<SurfaceId, std::shared_ptr<ClientBufferTracker>> client_buffer_tracker;

=== added file 'src/server/frontend/shell_wrapper.cpp'
--- src/server/frontend/shell_wrapper.cpp	1970-01-01 00:00:00 +0000
+++ src/server/frontend/shell_wrapper.cpp	2014-07-11 20:27:44 +0000
@@ -0,0 +1,74 @@
+/*
+ * 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]>
+ */
+
+#include "shell_wrapper.h"
+
+namespace mf = mir::frontend;
+
+std::shared_ptr<mf::Session> mf::ShellWrapper::open_session(
+    pid_t client_pid,
+    std::string const& name,
+    std::shared_ptr<EventSink> const& sink)
+{
+    return wrapped->open_session(client_pid, name,sink);
+}
+
+void mf::ShellWrapper::close_session(std::shared_ptr<Session> const& session)
+{
+    wrapped->close_session(session);
+}
+
+mf::SurfaceId mf::ShellWrapper::create_surface_for(
+    std::shared_ptr<Session> const& session,
+    scene::SurfaceCreationParameters const& params)
+{
+    return wrapped->create_surface_for(session, params);
+}
+
+void mf::ShellWrapper::handle_surface_created(
+    std::shared_ptr<Session> const& session)
+{
+    wrapped->handle_surface_created(session);
+}
+
+std::shared_ptr<mf::PromptSession> mf::ShellWrapper::start_prompt_session_for(
+    std::shared_ptr<Session> const& session,
+    scene::PromptSessionCreationParameters const& params)
+{
+    return wrapped->start_prompt_session_for(session, params);
+}
+
+void mf::ShellWrapper::add_prompt_provider_process_for(
+    std::shared_ptr<PromptSession> const& prompt_session,
+    pid_t process_id)
+{
+    wrapped->add_prompt_provider_process_for(prompt_session, process_id);
+}
+
+void mf::ShellWrapper::add_prompt_provider_for(
+    std::shared_ptr<PromptSession> const& prompt_session,
+    std::shared_ptr<Session> const& session)
+{
+    wrapped->add_prompt_provider_for(prompt_session, session);
+}
+
+void mf::ShellWrapper::stop_prompt_session(
+    std::shared_ptr<PromptSession> const& prompt_session)
+{
+    wrapped->stop_prompt_session(prompt_session);
+}

=== added file 'src/server/frontend/shell_wrapper.h'
--- src/server/frontend/shell_wrapper.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/shell_wrapper.h	2014-07-11 20:27:44 +0000
@@ -0,0 +1,70 @@
+/*
+ * 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_FRONTEND_SHELL_WRAPPER_H_
+#define MIR_FRONTEND_SHELL_WRAPPER_H_
+
+#include "mir/frontend/shell.h"
+
+namespace mir
+{
+namespace frontend
+{
+class ShellWrapper : public Shell
+{
+public:
+    explicit ShellWrapper(std::shared_ptr<Shell> const& wrapped) :
+        wrapped(wrapped) {}
+
+    virtual ~ShellWrapper() = default;
+
+    std::shared_ptr<Session> open_session(
+        pid_t client_pid,
+        std::string const& name,
+        std::shared_ptr<EventSink> const& sink) override;
+
+    void close_session(std::shared_ptr<Session> const& session)  override;
+
+    SurfaceId create_surface_for(
+        std::shared_ptr<Session> const& session,
+        scene::SurfaceCreationParameters const& params) override;
+
+    void handle_surface_created(std::shared_ptr<Session> const& session) override;
+
+    std::shared_ptr<PromptSession> start_prompt_session_for(
+        std::shared_ptr<Session> const& session,
+        scene::PromptSessionCreationParameters const& params) override;
+
+    void add_prompt_provider_process_for(
+        std::shared_ptr<PromptSession> const& prompt_session,
+        pid_t process_id) override;
+
+    void add_prompt_provider_for(
+        std::shared_ptr<PromptSession> const& prompt_session,
+        std::shared_ptr<Session> const& session) override;
+
+    void stop_prompt_session(
+        std::shared_ptr<PromptSession> const& prompt_session) override;
+
+protected:
+    std::shared_ptr<Shell> const wrapped;
+};
+}
+}
+
+#endif /* MIR_FRONTEND_SHELL_WRAPPER_H_ */

=== modified file 'src/server/frontend/socket_messenger.cpp'
--- src/server/frontend/socket_messenger.cpp	2014-06-12 15:35:08 +0000
+++ src/server/frontend/socket_messenger.cpp	2014-07-11 20:27:44 +0000
@@ -83,7 +83,7 @@
         send_fds_locked(lg, fds);
 }
 
-void mfd::SocketMessenger::send_fds_locked(std::unique_lock<std::mutex> const&, std::vector<int32_t> const& fds)
+void mfd::SocketMessenger::send_fds_locked(std::unique_lock<std::mutex> const&, std::vector<mir::Fd> const& fds)
 {
     if (fds.size() > 0)
     {
@@ -119,7 +119,7 @@
 
         int* const data = reinterpret_cast<int*>(CMSG_DATA(message));
         int i = 0;
-        for (auto fd : fds)
+        for (auto& fd : fds)
             data[i++] = fd;
 
         auto const sent = sendmsg(socket->native_handle(), &header, 0);

=== modified file 'src/server/frontend/socket_messenger.h'
--- src/server/frontend/socket_messenger.h	2014-06-03 11:04:15 +0000
+++ src/server/frontend/socket_messenger.h	2014-07-11 20:27:44 +0000
@@ -51,7 +51,7 @@
     std::mutex message_lock;
     SessionCredentials session_creds{0, 0, 0};
 
-    void send_fds_locked(std::unique_lock<std::mutex> const& lock, std::vector<int32_t> const& fds);
+    void send_fds_locked(std::unique_lock<std::mutex> const& lock, std::vector<Fd> const& fds);
 };
 }
 }

=== modified file 'src/server/graphics/CMakeLists.txt'
--- src/server/graphics/CMakeLists.txt	2014-06-03 11:04:15 +0000
+++ src/server/graphics/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -8,7 +8,6 @@
   gl_extensions_base.cpp
   program_factory.cpp
   surfaceless_egl_context.cpp
-  builtin_cursor_images.cpp
 )
 
 add_subdirectory(nested/)

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2014-06-24 21:44:55 +0000
+++ src/server/graphics/default_configuration.cpp	2014-07-11 20:27:44 +0000
@@ -39,8 +39,6 @@
 
 #include <boost/throw_exception.hpp>
 
-#include "builtin_cursor_images.h"
-
 #include <map>
 
 namespace mg = mir::graphics;
@@ -70,22 +68,31 @@
     return graphics_platform(
         [this]()->std::shared_ptr<mg::Platform>
         {
-            auto graphics_lib = mir::load_library(the_options()->get<std::string>(options::platform_graphics_lib));
-
             if (!the_options()->is_set(options::host_socket_opt))
             {
                 // fallback to standalone if host socket is unset
+                auto graphics_lib = mir::load_library(the_options()->get<std::string>(options::platform_graphics_lib));
                 auto create_platform = graphics_lib->load_function<mg::CreatePlatform>("create_platform");
                 return create_platform(the_options(), the_emergency_cleanup(), the_display_report());
             }
 
-            auto create_native_platform = graphics_lib->load_function<mg::CreateNativePlatform>("create_native_platform");
-
             return std::make_shared<mir::graphics::nested::NestedPlatform>(
                 the_host_connection(),
                 the_input_dispatcher(),
                 the_display_report(),
-                create_native_platform(the_display_report()));
+                the_graphics_native_platform());
+        });
+}
+
+std::shared_ptr<mg::NativePlatform>  mir::DefaultServerConfiguration::the_graphics_native_platform()
+{
+    return graphics_native_platform(
+        [this]()
+        {
+            auto graphics_lib = mir::load_library(the_options()->get<std::string>(options::platform_graphics_lib));
+            auto create_native_platform = graphics_lib->load_function<mg::CreateNativePlatform>("create_native_platform");
+
+            return create_native_platform(the_display_report());
         });
 }
 
@@ -145,28 +152,6 @@
         });
 }
 
-std::shared_ptr<mg::CursorImage>
-mir::DefaultServerConfiguration::the_default_cursor_image()
-{
-    static geometry::Size const default_cursor_size = {geometry::Width{64},
-                                                       geometry::Height{64}};
-    return default_cursor_image(
-        [this]()
-        {
-            return the_cursor_images()->image(mir_default_cursor_name, default_cursor_size);
-        });
-}
-
-std::shared_ptr<mg::CursorImages>
-mir::DefaultServerConfiguration::the_cursor_images()
-{
-    return cursor_images(
-        [this]()
-        {
-            return std::make_shared<mg::BuiltinCursorImages>();
-        });
-}
-
 auto mir::DefaultServerConfiguration::the_host_connection()
 -> std::shared_ptr<graphics::nested::HostConnection>
 {

=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2014-06-02 17:07:02 +0000
+++ src/server/graphics/nested/nested_display.cpp	2014-07-11 20:27:44 +0000
@@ -215,10 +215,6 @@
                 });
         });
 
-    if (result.empty())
-        BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir needs at least one output for display"));
-
-
     {
         std::unique_lock<std::mutex> lock(outputs_mutex);
         outputs.swap(result);

=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2014-06-24 15:28:09 +0000
+++ src/server/input/CMakeLists.txt	2014-07-11 20:27:44 +0000
@@ -1,5 +1,7 @@
 include_directories(${MIR_3RD_PARTY_INCLUDE_DIRECTORIES})
 include_directories(${MIR_ANDROID_INCLUDE_DIRECTORIES})
+include_directories(${MIR_XCURSOR_INCLUDE_DIRECTORIES})
+
 set(
   INPUT_SOURCES
 
@@ -8,11 +10,12 @@
   null_input_channel_factory.cpp
   null_input_configuration.cpp
   null_input_dispatcher.cpp
-  nested_input_configuration.cpp
   display_input_region.cpp
   vt_filter.cpp
   cursor_controller.cpp
   default_configuration.cpp
+  xcursor_loader.cpp
+  builtin_cursor_images.cpp
 )
 
 add_subdirectory(android)
@@ -23,3 +26,7 @@
   ${INPUT_SOURCES}
 )
 uses_android_input(mirinput)
+target_link_libraries(
+  mirinput
+  xcursorloader
+)

=== renamed file 'src/server/graphics/black_arrow.c' => 'src/server/input/black_arrow.c'
=== renamed file 'src/server/graphics/black_arrow.xcf' => 'src/server/input/black_arrow.xcf'
=== renamed file 'src/server/graphics/builtin_cursor_images.cpp' => 'src/server/input/builtin_cursor_images.cpp'
--- src/server/graphics/builtin_cursor_images.cpp	2014-04-23 23:07:05 +0000
+++ src/server/input/builtin_cursor_images.cpp	2014-07-11 20:27:44 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/graphics/cursor_image.h"
 
+namespace mi = mir::input;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
@@ -36,15 +37,19 @@
     {
         return { black_arrow.width, black_arrow.height };
     }
+    geom::Displacement hotspot() const
+    {
+        return {0, 0};
+    }
 };
 }
 
-mg::BuiltinCursorImages::BuiltinCursorImages()
+mi::BuiltinCursorImages::BuiltinCursorImages()
     : builtin_image(std::make_shared<BlackArrowCursorImage>())
 {
 }
 
-std::shared_ptr<mg::CursorImage> mg::BuiltinCursorImages::image(std::string const& /* cursor_name */,
+std::shared_ptr<mg::CursorImage> mi::BuiltinCursorImages::image(std::string const& /* cursor_name */,
     geom::Size const& /* size */)
 {
     // Builtin repository only has one cursor at a single size.

=== renamed file 'src/server/graphics/builtin_cursor_images.h' => 'src/server/input/builtin_cursor_images.h'
--- src/server/graphics/builtin_cursor_images.h	2014-04-23 23:07:05 +0000
+++ src/server/input/builtin_cursor_images.h	2014-07-11 20:27:44 +0000
@@ -17,24 +17,22 @@
  */
 
 
-#ifndef MIR_GRAPHICS_BUILTIN_CURSOR_LOADER_H_
-#define MIR_GRAPHICS_BUILTIN_CURSOR_LOADER_H_
+#ifndef MIR_INPUT_BUILTIN_CURSOR_IMAGES_H_
+#define MIR_INPUT_BUILTIN_CURSOR_IMAGES_H_
 
-#include "mir/graphics/cursor_images.h"
+#include "mir/input/cursor_images.h"
 
 namespace mir
 {
-namespace graphics
+namespace input
 {
-class CursorImage;
-
 class BuiltinCursorImages : public CursorImages
 {
 public:
     BuiltinCursorImages();
     virtual ~BuiltinCursorImages() = default;
 
-    std::shared_ptr<CursorImage> image(std::string const& cursor_name,
+    std::shared_ptr<graphics::CursorImage> image(std::string const& cursor_name,
         geometry::Size const& size);
 
 protected:
@@ -42,10 +40,10 @@
     BuiltinCursorImages& operator=(BuiltinCursorImages const&) = delete;
 
 private:
-    std::shared_ptr<CursorImage> const builtin_image;
+    std::shared_ptr<graphics::CursorImage> const builtin_image;
 };
 }
 }
 
 
-#endif /* MIR_GRAPHICS_BUILTIN_CURSOR_LOADER_H_ */
+#endif /* MIR_INPUT_BUILTIN_CURSOR_IMAGES_H_ */

=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2014-06-26 16:10:36 +0000
+++ src/server/input/default_configuration.cpp	2014-07-11 20:27:44 +0000
@@ -28,11 +28,12 @@
 #include "android/input_channel_factory.h"
 #include "display_input_region.h"
 #include "event_filter_chain.h"
-#include "nested_input_configuration.h"
 #include "null_input_configuration.h"
 #include "cursor_controller.h"
 #include "null_input_dispatcher.h"
 #include "null_input_targeter.h"
+#include "xcursor_loader.h"
+#include "builtin_cursor_images.h"
 #include "null_input_send_observer.h"
 #include "null_input_channel_factory.h"
 
@@ -50,6 +51,7 @@
 namespace mia = mi::android;
 namespace mr = mir::report;
 namespace ms = mir::scene;
+namespace mg = mir::graphics;
 namespace msh = mir::shell;
 
 std::shared_ptr<mi::InputRegion> mir::DefaultServerConfiguration::the_input_region()
@@ -79,11 +81,11 @@
     [this]() -> std::shared_ptr<mi::InputConfiguration>
     {
         auto const options = the_options();
-        if (!options->get<bool>(options::enable_input_opt))
-        {
-            return std::make_shared<mi::NullInputConfiguration>();
-        }
-        else if (!options->is_set(options::host_socket_opt))
+        bool input_reading_required =
+            options->get<bool>(options::enable_input_opt) &&
+            !options->is_set(options::host_socket_opt);
+
+        if (input_reading_required)
         {
             // fallback to standalone if host socket is unset
             return std::make_shared<mia::DefaultInputConfiguration>(
@@ -95,7 +97,7 @@
         }
         else
         {
-            return std::make_shared<mi::NestedInputConfiguration>();
+            return std::make_shared<mi::NullInputConfiguration>();
         }
     });
 }
@@ -235,3 +237,37 @@
         });
 
 }
+
+std::shared_ptr<mg::CursorImage>
+mir::DefaultServerConfiguration::the_default_cursor_image()
+{
+    return default_cursor_image(
+        [this]()
+        {
+            return the_cursor_images()->image(mir_default_cursor_name, mi::default_cursor_size);
+        });
+}
+
+namespace
+{
+bool has_default_cursor(mi::CursorImages& images)
+{
+    if (images.image(mir_default_cursor_name, mi::default_cursor_size))
+        return true;
+    return false;
+}
+}
+
+std::shared_ptr<mi::CursorImages>
+mir::DefaultServerConfiguration::the_cursor_images()
+{
+    return cursor_images(
+        [this]() -> std::shared_ptr<mi::CursorImages>
+        {
+            auto xcursor_loader = std::make_shared<mi::XCursorLoader>();
+            if (has_default_cursor(*xcursor_loader))
+                return xcursor_loader;
+            else
+                return std::make_shared<mi::BuiltinCursorImages>();
+        });
+}

=== removed file 'src/server/input/nested_input_configuration.cpp'
--- src/server/input/nested_input_configuration.cpp	2014-06-24 15:28:09 +0000
+++ src/server/input/nested_input_configuration.cpp	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-/*
- * 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: Alan Griffiths <[e-mail]>
- *              Andreas Pokorny <[e-mail]>
- */
-
-#include "nested_input_configuration.h"
-#include "null_input_manager.h"
-
-#include "android/input_channel_factory.h"
-
-#include <memory>
-
-namespace mi = mir::input;
-namespace mia = mir::input::android;
-
-std::shared_ptr<mi::InputManager> mi::NestedInputConfiguration::the_input_manager()
-{
-    return input_manager(
-        [this]()
-        {
-            return std::make_shared<NullInputManager>();
-        });
-}

=== removed file 'src/server/input/nested_input_configuration.h'
--- src/server/input/nested_input_configuration.h	2014-06-24 15:28:09 +0000
+++ src/server/input/nested_input_configuration.h	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-/*
- * Copyright © 2013 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/>.
- *