Merge lp:~cemil-azizoglu/mir/mir-render-surface into lp:mir

[Cemil Azizoglu]

[lp:~cemil-azizoglu/mir/mir-render-surface]

3591. By Kevin DuBois on 2016-07-15

Suppress memory leak in libhybris generated when probing android platforms.

also disable a failing mir_privileged_test until proper fix can be found.
(LP: #1603145)

Fixes: LP: #1602199

3592. By Alan Griffiths on 2016-07-15

Add missing dependencies to mirtest.pc (LP: #1603080)

3593. By Daniel van Vugt on 2016-07-15

Fix build/autolanding failure due to ODR violation in MockEGL
(LP: #1603303)

Since /usr/include/EGL/eglplatform.h is full of #ifdefs and the Mir
source uses multiple different interpretations of those #ifdefs,
we can't safely define any C++ class that accepts the Native* types
as parameters.
. Fixes: https://bugs.launchpad.net/bugs/1603303.

Approved by Daniel van Vugt, mir-ci-bot.

3594. By Daniel van Vugt on 2016-07-15

Fix Super key not working any more since r3565 (LP: #1602966), so that
the kernel's KEY_LEFTMETA once again maps to Mir's
mir_input_event_modifier_meta_left.

It was an understandable mistake as the Super key is actually:
   Kernel: KEY_LEFTMETA
   XKB: XKB_KEY_Super_L (not XKB_KEY_Meta_L)
   Mir: mir_input_event_modifier_meta_left
. Fixes: https://bugs.launchpad.net/bugs/1602966.

Approved by mir-ci-bot, Cemil Azizoglu.

3595. By Daniel van Vugt on 2016-07-18

Bump version to 0.25.0; we already branched series 0.24.

Approved by mir-ci-bot, Cemil Azizoglu.

3596. By Daniel van Vugt on 2016-07-18

Forward-port a one-line fix from lp:mir/0.24 where the fix for
LP: #1603303 caused build failure. Only fails in lp:mir/0.24 right now
but best to keep the branches in sync. Fixes: https://bugs.launchpad.net/bugs/1603303.

Approved by Alan Griffiths, mir-ci-bot.

3597. By Alan Griffiths on 2016-07-19

Avoid statically linking mircommon objects - having just one copy in the .so avoids (potential) issues.

Approved by Kevin DuBois, mir-ci-bot.

3598. By Alan Griffiths on 2016-07-19

Enhanced mir_test_framework::library_path() to better locate the Mir library directory (and fix problems using libmir-test-assist.a downstream). Fixes: https://bugs.launchpad.net/bugs/1603091.

Approved by mir-ci-bot, Kevin DuBois.

3599. By Kevin DuBois on 2016-07-19

fix LP: #1603114 by removing the stub_input_platform.cpp from the mir-test-assist.a library (its header is private anyways). Link mir_umock_unit_tests to the object file instead.

fixes: LP: #1603114. Fixes: https://bugs.launchpad.net/bugs/1603114.

Approved by mir-ci-bot, Alan Griffiths.

3600. By Daniel van Vugt on 2016-07-19

Attempt to build and package missing arm64 binaries for
the Android platform (LP: #1579866). Fixes: https://bugs.launchpad.net/bugs/1579866.

Approved by mir-ci-bot, Łukasz Zemczak, Kevin DuBois.

3601. By Kevin DuBois on 2016-07-19

fix ftbfs in xenial and yakkety overlays. Problem seems to be some sort of template instantiation location problem problem with gmock in libmir-test-assist, but haven't been able to find a solution that keeps mir_umock_acceptance_tests reliant on mir-test-assist though.

fixes LP: #1601810. Fixes: https://bugs.launchpad.net/bugs/1601810.

Approved by mir-ci-bot, Cemil Azizoglu, Alan Griffiths.

3602. By Daniel van Vugt on 2016-07-20

bzrignore: Don't ignore the 'build' directory. That prevents the command
'bzr clean-tree' from removing it. Which for my muscle memory at least
is annoying.

Also, doesn't anyone else occasionally have other build directories not
called 'build'? Treating that name as special is inconsistent as only
the other build dirs not called 'build' will get cleaned out.

Approved by Kevin DuBois, mir-ci-bot.

3603. By Kevin DuBois on 2016-07-21

update symbols to reflect the symbols actually captured in the 0.24 release.

Approved by Daniel van Vugt, mir-ci-bot.

3604. By Alan Griffiths on 2016-07-21

Deprecate useless mir_connection_create_spec_for_tooltip() and add mir_connection_create_spec_for_tip(). Fixes: https://bugs.launchpad.net/bugs/1603922.

Approved by mir-ci-bot, Kevin DuBois, Cemil Azizoglu.

3605. By Daniel van Vugt on 2016-07-21

Fix one space typo that's the only obviously wrong difference between
0.24 and 0.25 after this lands: lp:~kdub/mir/update-symbols-from-0.24
.

Approved by mir-ci-bot, Cemil Azizoglu.

3606. By Alan Griffiths on 2016-07-21

Use "struct Rectangle" consistently.

Approved by mir-ci-bot, Cemil Azizoglu, Kevin DuBois.

3607. By Kevin DuBois on 2016-07-22

android: plumb the fencing support that the NBS api needs. Specifically, add timeout-based fence waits.

Also change the public MirNativeFence* (which was a void**) to just a MirNativeFence (void*) to be easier to use/less misleading.

Approved by Cemil Azizoglu, Alan Griffiths, mir-ci-bot.

3608. By Daniel van Vugt on 2016-07-22

Revert previous commit. It fails to build on yakkety desktop.

3609. By Kevin DuBois on 2016-07-25

reorganize the nested code a bit so that there's a mgn::Platform that overrides the display creation, instead of relying on the DefaultConfiguration to intercept create_display calls. Prepares for "nested passthrough" where the nested server will have to give a MirBuffer from the host server to its client. (And will have to override the GraphicsBufferAllocator, much like its currently overriding the Display).

Approved by Alexandros Frantzis, Chris Halse Rogers, mir-ci-bot.

3610. By Daniel van Vugt on 2016-07-25

Make desktop zoom with touchpads smoother and more usable.

This doesn't change anything for mouse wheels as they emit vscroll values
of 1 or -1 anyway. For touchpads, this makes zooming smoother and more
controllable. (Super+mousewheel or Super+two-finger-scroll).

Approved by Alexandros Frantzis, mir-ci-bot, Chris Halse Rogers.

3611. By Brandon Schaefer on 2016-07-25

Update the confine region if we are modifying the state/width/height. Fixes: https://bugs.launchpad.net/bugs/1604673.

Approved by Alan Griffiths, mir-ci-bot.

3612. By Brandon Schaefer on 2016-07-26

Put the symbol in the 0.24 section (which has already been split for release). Make a new symbol section 0.25 and put that symbol there.

Approved by mir-ci-bot, Daniel van Vugt, Chris Halse Rogers.

3613. By Cemil Azizoglu on 2016-07-27

Refine x11 build files.

Approved by Alexandros Frantzis, mir-ci-bot.

3614. By Alexandros Frantzis on 2016-07-27

platform: Introduce Display::native_display().

Approved by mir-ci-bot, Cemil Azizoglu, Andreas Pokorny, Kevin DuBois.

3615. By Chris Halse Rogers on 2016-07-28

Improvements to no-TLS-future.

Since we hope that the bionic-and-hybris-fight-over-TLS-slots bug will - in some halcyon future - be fixed this branch makes NoTLSFuture behave more like std::future so we hopefully don't rely on non-standard behaviour.

Additionally, because a continuation interface would be really handy for removing an implicit RPC wait in BufferStream, implement a reasonable approximation of the .then() interface in the Concurrency TS (N4107 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4107.html#future).

Approved by Alexandros Frantzis, Alan Griffiths, mir-ci-bot.

3616. By Andreas Pokorny on 2016-07-28

Combine mirclientrpc-static and mirclient-static itself into a single static library

This avoids static library linking order problems between code that is defined inside client/events and client/rpc which before ended up in mirclient-static and mirclientrpc-static.

Approved by Kevin DuBois, Alan Griffiths, mir-ci-bot.

3617. By Alexandros Frantzis on 2016-07-29

tests: Fix ServerConfigurationOptions test to run safely with ptest. Fixes: https://bugs.launchpad.net/bugs/1607351.

Approved by mir-ci-bot, Alan Griffiths.

3618. By Kevin DuBois on 2016-07-29

android: Plumb the fencing support that the NBS API needs. Specifically, add timeout-based fence waits.

Also change the public MirNativeFence* (which was a void**) to just a MirNativeFence (void*) to be easier to use/less misleading.

Approved by mir-ci-bot, Cemil Azizoglu, Alan Griffiths.

3619. By Alexandros Frantzis on 2016-08-01

platform: Move GL specific methods from mg::Display to mir::renderer::gl::ContextSource.

Approved by Alan Griffiths, Cemil Azizoglu, Kevin DuBois, mir-ci-bot.

3620. By Daniel van Vugt on 2016-08-01

Add some value totals to a few enums visible in the client API.
And also fix some switch statements that then complain due to missing
'default:'.

I needed these enum values yesterday when working on Xmir but found
they did not exist.
.

Approved by mir-ci-bot, Alan Griffiths, Cemil Azizoglu.

3621. By Brandon Schaefer on 2016-08-02

Use a different way to tell the abstract shell to update its seat.

Fixes a race in the test. We update the confinement on a resized_to or a move_to in the surface observer. The order is not guaranteed or rather most cases we are getting the callback in the test that we resized before the abstract shell. Leading to a race.

To fix this, we have implemented a seat report that will report when events are done. Now we can mock this and check we got this report. This will be good for normal logging. I will finish up the rest of the events for the seat report after this branch. Fixes: https://bugs.launchpad.net/bugs/1606418.

Approved by mir-ci-bot, Alan Griffiths, Andreas Pokorny.

3622. By Daniel van Vugt on 2016-08-03

Document the FAQ about mirvanity accuracy.

Approved by Cemil Azizoglu, mir-ci-bot.

3623. By Daniel van Vugt on 2016-08-03

Clarify comments around full desktop GL support. It's likely no further
changes are required in the Mir source and we're just waiting on an
upstream Mesa fix.
. Fixes: https://bugs.launchpad.net/bugs/1420581.

Approved by mir-ci-bot, Cemil Azizoglu.

3624. By Brandon Schaefer on 2016-08-03

A demo to show off pointer confinement and a way to test it out. Need to look at fullscreen and other possible issues.

Approved by mir-ci-bot, Daniel van Vugt, Alan Griffiths.

3625. By Daniel van Vugt on 2016-08-03

Fix lots of clang warnings/errors that cause build failure.

Approved by Alan Griffiths, mir-ci-bot.

3626. By Alexandros Frantzis on 2016-08-03

Fix precompiled header builds with gcc-6.

Approved by mir-ci-bot, Alan Griffiths.

3627. By Alexandros Frantzis on 2016-08-04

renderer: Begin extraction of renderer interfaces to their own library and package.

Approved by Alan Griffiths, Cemil Azizoglu, mir-ci-bot.

3628. By Daniel van Vugt on 2016-08-04

FD zero is valid and not an error. Just highly unlikely you'll ever see
zero being used unless you've closed your stdin first.

Approved by mir-ci-bot, Alan Griffiths.

3629. By Alan Griffiths on 2016-08-04

Add new dependency on mir-renderer-gl-dev to mirtest.pc

3630. By Kevin DuBois on 2016-08-05

fix "cmake .. -DMIR_PLATFORM=android" build.

fixes: LP: #1609916
. Fixes: https://bugs.launchpad.net/bugs/1609916.

Approved by Daniel van Vugt, mir-ci-bot.

3631. By Daniel van Vugt on 2016-08-05

Fix a few problems that have prevented cross-compile-chroot.sh from
actually working in a while (LP: #1609329)

  * Fixed error: Some build deps not found (because they are in
    universe rather than main?).
  * Fixed error: Building on yakkety as of recently (today) defaults
    to GCC 6, so the default compiler version when targeting xenial
    or wily now needs to be explicitly set to 5.
  * Fixed error: Precompiled headers from GCC 6 don't work when
    targeting any distro other than yakkety, so don't use them.
  * Fixed error: Some headers from android-headers-23 are missing
    #includes, but apparently only when cross-compiling.
  * Fixed warning: Missing public keys for Ubuntu archive.
. Fixes: https://bugs.launchpad.net/bugs/1609329.

Approved by mir-ci-bot, Chris Halse Rogers, Kevin DuBois.

3632. By Alan Griffiths on 2016-08-05

We don't need mir_add_library_with_symbols() (a self confessed "abysmal hack"). We should use LINK_DEPENDS which is "intended to specify dependencies on “linker scripts” for custom Makefile link rules.".

Approved by Daniel van Vugt, Kevin DuBois, mir-ci-bot.

3633. By Daniel van Vugt on 2016-08-05

eglstream: Simplify logging calls
.

Approved by Alan Griffiths, Andreas Pokorny, mir-ci-bot.

3634. By Alexandros Frantzis on 2016-08-08

tests: Don't build with LTO. Fixes: https://bugs.launchpad.net/bugs/1610215.

Approved by Daniel van Vugt, Cemil Azizoglu, Kevin DuBois, mir-ci-bot.

3635. By Daniel van Vugt on 2016-08-09

Work around clang build failure on yakkety with the gcc6 headers
(LP: #1609612)

It seems like such a simple problem, but I can't figure out a solution
yet. Only removing the expectation allows the build to complete. And
all tests pass.
. Fixes: https://bugs.launchpad.net/bugs/1609612.

Approved by Cemil Azizoglu, mir-ci-bot.

3636. By Ratchanan Srirattanamet on 2016-08-09

android: make use of new PbufferGLContext constructor in DeviceQuirks

Originally, DeviceQuirks creates a PbufferGLContext with
mir_pixel_format_abgr_8888 hard-coded as a format. This causes a problem
on a device without mir_pixel_format_abgr_8888 support. This revision
make use of new PbufferGLContext constructor which doesn't have to
specify a display format. This makes the code not depending on the
availability of mir_pixel_format_abgr_8888 format on the device.

Approved by: camako, kdub, alan_g, duflu

3637. By Alan Griffiths on 2016-08-10

Avoid potential use of an unspecified state when testing with the stub graphics platform (LP: #1611337). Fixes: https://bugs.launchpad.net/bugs/1611337.

Approved by Daniel van Vugt, mir-ci-bot.

3638. By Daniel van Vugt on 2016-08-10

On those devices that have KMS but no hardware cursor support,
fall back automatically to the software cursor (LP: #1610054). Fixes: https://bugs.launchpad.net/bugs/1610054.

Approved by Cemil Azizoglu, mir-ci-bot.

3639. By Andreas Pokorny on 2016-08-10

Fix server hang ups and allocation failures when client recreate buffer streams

When a mir client destroys a buffer stream the destruction result callback will trigger a buffer release of the associated buffers. That buffer release request inevitable fails in session mediator because it fails to resolve the BufferStreamId. This change handles exceptions during the attempt to disassociate buffers from already deleted buffer streams to ensure that the actual buffer release can happen.

This error is not really a leak - the buffers were deleted when the client disconnects and the server would be able to serve new clients.

Approved by Kevin DuBois, mir-ci-bot.

3640. By Kevin DuBois on 2016-08-10

Increase timeout for MultiThreadedCompositor.cleans_up_after_throw_in_start test,
which can fail when CI is very slow

fixes: LP: #1595940. Fixes: https://bugs.launchpad.net/bugs/1595940.

Approved by mir-ci-bot, Alan Griffiths, Cemil Azizoglu.

3641. By Alexandros Frantzis on 2016-08-11

Fix clang build on yakkety. Fixes: https://bugs.launchpad.net/bugs/1609612.

Approved by mir-ci-bot, Chris Halse Rogers, Daniel van Vugt, Alan Griffiths, Cemil Azizoglu.

3642. By Chris Halse Rogers on 2016-08-11

Add subpixel arrangement info to the display configuration API.

Current platforms only provide mir_subpixel_arrangement_unknown, and need to add support for setting this to platform-provided values before this will be useful.

Fixes (part one): https://bugs.launchpad.net/mir/+bug/1393578. Fixes: https://bugs.launchpad.net/bugs/1393578.

Approved by mir-ci-bot, Cemil Azizoglu, Daniel van Vugt, Kevin DuBois.

3643. By Chris Halse Rogers on 2016-08-12

Improvements to mtd::FakeDisplay.

Throw an exception when writing to/reading from the configuration change event trigger fails rather than silently continuing, blithely unaware that the call has failed.

Switch from a pipe to an eventfd; eventfd is the solution tailored for this use-case.

Presented in the forlorn hope that it makes a test that appears to be flaky on vivid+clang, but does not appear that it's possible for it to be flaky, stops being flaky. Either by consistently passing, or consistently failing!.

Approved by Alexandros Frantzis, Kevin DuBois, mir-ci-bot.

3644. By Kevin DuBois on 2016-08-12

Have the MirSurface report the shell-designated size like it used to, instead of the spec-requested size.

fixes: LP: #1612256. Fixes: https://bugs.launchpad.net/bugs/1612256.

Approved by mir-ci-bot, Alan Griffiths.

3645. By Andreas Pokorny on 2016-08-12

Use the pixel format of the individual buffer stream to infer shaped()

It is a valid scenario to have an opaque buffer (or buffer stream) for the first layer in a surface and have further transparent or also opaque layers on top. This change removes the constant "non_rectangular" parameter of BasicSurface, and instead looks at the actual streams that are attached to surface.

With mir_presentation_queue it might be worth thinking about going one step further and actually look at the mg::Buffer that would be drawn next. An attempt to do so showed that it would require a few further refactoring steps in our integration test setup.
.

Approved by Kevin DuBois, mir-ci-bot, Alexandros Frantzis.

3646. By Chris Halse Rogers on 2016-08-12

Provide subpixel arrangement info from the mesa-kms platform. Fixes: https://bugs.launchpad.net/bugs/1393578.

Approved by mir-ci-bot, Kevin DuBois, Cemil Azizoglu.

Unmerged revisions

3647. By Cemil Azizoglu on 2016-07-14

MirRenderSurface works - no tests

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-10 10:43:39 +0000
+++ CMakeLists.txt	2016-08-12 21:54:21 +0000
@@ -189,6 +189,14 @@
   endif()
 endforeach(platform)
 
+#set(EGL_LIBRARIES EGL)
+#set(EGL_INCLUDE_DIRS /home/camako/git/mesa/usr/local/include)
+
+#set(GLESv2_LIBRARIES GLESv2)
+#set(GLESv2_INCLUDE_DIRS /home/camako/git/mesa/usr/local/include)
+
+#link_directories(/home/camako/git/mesa/usr/local/lib)
+
 find_package(EGL REQUIRED)
 find_package(GLESv2 REQUIRED)
 find_package(GLM REQUIRED)

=== modified file 'playground/CMakeLists.txt'
--- playground/CMakeLists.txt	2016-08-01 14:43:19 +0000
+++ playground/CMakeLists.txt	2016-08-12 21:54:21 +0000
@@ -30,6 +30,15 @@
     m
 )
 
+mir_add_wrapped_executable(mir_demo_client_render_surface
+  render_surface.cpp
+)
+
+target_link_libraries(mir_demo_client_render_surface
+    mirclient
+    eglapp
+)
+
 mir_add_wrapped_executable(mir_demo_client_chain_jumping_buffers
     mir_demo_client_chain_jumping_buffers.c
 )
@@ -37,3 +46,13 @@
 target_link_libraries(mir_demo_client_chain_jumping_buffers
     mirclient
 )
+
+mir_add_wrapped_executable(mir_demo_client_eglflash_render_surface
+    eglflash_render_surface.c
+)
+
+target_link_libraries(mir_demo_client_eglflash_render_surface
+    mirclient
+    ${EGL_LIBRARIES}
+    ${GLESv2_LIBRARIES}
+)

=== added file 'playground/eglflash_render_surface.c'
--- playground/eglflash_render_surface.c	1970-01-01 00:00:00 +0000
+++ playground/eglflash_render_surface.c	2016-08-12 21:54:21 +0000
@@ -0,0 +1,152 @@
+/*
+ * Trivial GL demo; flashes the screen with colors using a MirRenderSurface.
+ *
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Cemil Azizoglu <[e-mail]>
+ */
+
+#include <mir_toolkit/mir_client_library.h>
+#include "mir_toolkit/mir_render_surface.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <pthread.h>
+
+typedef struct Color
+{
+    GLfloat r, g, b, a;
+} Color;
+
+#define CHECK(_cond, _err) \
+    if (!(_cond)) \
+    { \
+       printf("%s\n", (_err)); \
+       return -1; \
+    }
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+    unsigned int num_frames = 0;
+    const char* appname = "EGL Render Surface Demo";
+    int width = 100;
+    int height = 100;
+    EGLDisplay egldisplay;
+    EGLSurface eglsurface;
+    EGLint ctxattribs[] =
+    {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+    EGLContext eglctx;
+    EGLConfig eglconfig;
+    EGLint neglconfigs;
+    EGLBoolean ok;
+    MirConnection* connection = NULL;
+    MirSurface* surface = NULL;
+    MirRenderSurface* render_surface = NULL;
+
+    connection = mir_connect_sync(NULL, appname);
+    CHECK(mir_connection_is_valid(connection), "Can't get connection");
+
+    egldisplay = eglGetDisplay(
+                    mir_connection_get_egl_native_display(connection));
+    CHECK(egldisplay != EGL_NO_DISPLAY, "Can't eglGetDisplay");
+
+    ok = eglInitialize(egldisplay, NULL, NULL);
+    CHECK(ok, "Can't eglInitialize");
+
+    const EGLint attribs[] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_RED_SIZE, 8,
+        EGL_GREEN_SIZE, 8,
+        EGL_BLUE_SIZE, 8,
+        EGL_ALPHA_SIZE, 8,
+        EGL_NONE
+    };
+
+    ok = eglChooseConfig(egldisplay, attribs, &eglconfig, 1, &neglconfigs);
+    CHECK(ok, "Could not eglChooseConfig");
+    CHECK(neglconfigs > 0, "No EGL config available");
+
+    MirPixelFormat pixel_format =
+        mir_connection_get_egl_pixel_format(connection, egldisplay, eglconfig);
+
+    printf("Mir chose pixel format %d.\n", pixel_format);
+
+    MirSurfaceSpec *spec =
+        mir_connection_create_spec_for_normal_surface(connection, width, height, pixel_format);
+    CHECK(spec, "Can't create a surface spec");
+
+    mir_surface_spec_set_name(spec, appname);
+
+    render_surface = mir_connection_create_render_surface(connection);
+    CHECK(mir_render_surface_is_valid(render_surface), "could not create render surface");
+
+    mir_surface_spec_add_render_surface(spec, width, height, 0, 0, render_surface);
+
+    surface = mir_surface_create_sync(spec);
+
+    mir_surface_spec_release(spec);
+
+    eglsurface = eglCreateWindowSurface(egldisplay, eglconfig,
+        (EGLNativeWindowType)mir_render_surface_egl_native_window(render_surface), NULL);
+    CHECK(eglsurface != EGL_NO_SURFACE, "eglCreateWindowSurface failed");
+
+    eglctx = eglCreateContext(egldisplay, eglconfig, EGL_NO_CONTEXT,
+                              ctxattribs);
+    CHECK(eglctx != EGL_NO_CONTEXT, "eglCreateContext failed");
+
+    ok = eglMakeCurrent(egldisplay, eglsurface, eglsurface, eglctx);
+    CHECK(ok, "Can't eglMakeCurrent");
+
+    Color red = {1.0f, 0.0f, 0.0f, 1.0f};
+    Color green = {0.0f, 1.0f, 0.0f, 1.0f};
+    Color blue = {0.0f, 0.0f, 1.0f, 1.0f};
+
+    do
+    {
+        printf("here %d\n", num_frames);
+        glClearColor(red.r, red.g, red.b, red.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        eglSwapBuffers(egldisplay, eglsurface);
+        sleep(1);
+
+        glClearColor(green.r, green.g, green.b, green.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        eglSwapBuffers(egldisplay, eglsurface);
+        sleep(1);
+
+        glClearColor(blue.r, blue.g, blue.b, blue.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        eglSwapBuffers(egldisplay, eglsurface);
+        sleep(1);
+    } while (num_frames++ < 3);
+
+    eglMakeCurrent(egldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglTerminate(egldisplay);
+    mir_render_surface_release(render_surface);
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+
+    return 0;
+}

=== added file 'playground/render_surface.cpp'
--- playground/render_surface.cpp	1970-01-01 00:00:00 +0000
+++ playground/render_surface.cpp	2016-08-12 21:54:21 +0000
@@ -0,0 +1,253 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Cemil Azizoglu <[e-mail]>
+ */
+
+#include <boost/program_options.hpp>
+#include <iostream>
+#include <thread>
+#include <signal.h>
+#include <sys/signalfd.h>
+#include <poll.h>
+
+#include "mir_toolkit/mir_client_library.h"
+#include "mir_toolkit/mir_render_surface.h"
+#include "mir_toolkit/mir_presentation_chain.h"
+
+#include "client_helpers.h"
+
+namespace me = mir::examples;
+
+class Pixel
+{
+public:
+    Pixel(void* addr, MirPixelFormat format)
+        : addr{addr},
+          format{format}
+    {
+    }
+
+    void write(int r, int g, int b, int a)
+    {
+        switch (format)
+        {
+        case mir_pixel_format_abgr_8888:
+            *((uint32_t*) addr) =
+                (uint32_t) a << 24 |
+                (uint32_t) b << 16 |
+                (uint32_t) g << 8 |
+                (uint32_t) r;
+            break;
+        case mir_pixel_format_xbgr_8888:
+            *((uint32_t*) addr) =
+                /* Not filling in the X byte is correct but buggy (LP: #1423462) */
+                (uint32_t) b << 16 |
+                (uint32_t) g << 8 |
+                (uint32_t) r;
+            break;
+        case mir_pixel_format_argb_8888:
+            *((uint32_t*) addr) =
+                (uint32_t) a << 24 |
+                (uint32_t) r << 16 |
+                (uint32_t) g << 8 |
+                (uint32_t) b;
+            break;
+        case mir_pixel_format_xrgb_8888:
+            *((uint32_t*) addr) =
+                /* Not filling in the X byte is correct but buggy (LP: #1423462) */
+                (uint32_t) r << 16 |
+                (uint32_t) g << 8 |
+                (uint32_t) b;
+            break;
+        case mir_pixel_format_rgb_888:
+            *((uint8_t*) addr) = r;
+            *((uint8_t*) addr + 1) = g;
+            *((uint8_t*) addr + 2) = b;
+            break;
+        case mir_pixel_format_bgr_888:
+            *((uint8_t*) addr) = b;
+            *((uint8_t*) addr + 1) = g;
+            *((uint8_t*) addr + 2) = r;
+            break;
+        default:
+            throw std::runtime_error{"Pixel format unsupported by Pixel::write!"};
+        }
+    }
+
+public:
+    void* const addr;
+    MirPixelFormat const format;
+};
+
+class pixel_iterator : std::iterator<std::random_access_iterator_tag, Pixel>
+{
+public:
+    pixel_iterator(MirGraphicsRegion const& region, int x, int y)
+        : x{x},
+          y{y},
+          buffer(region)
+    {
+    }
+
+    pixel_iterator(MirGraphicsRegion const& region)
+       : pixel_iterator(region, 0, 0)
+    {
+    }
+
+
+    pixel_iterator& operator++()
+    {
+        x++;
+        if (x == buffer.width)
+        {
+            x = 0;
+            y++;
+        }
+        return *this;
+    }
+    pixel_iterator operator++(int)
+    {
+        auto old = *this;
+        ++(*this);
+        return old;
+    }
+
+    Pixel operator*() const
+    {
+        return Pixel{
+            buffer.vaddr + (x * MIR_BYTES_PER_PIXEL(buffer.pixel_format))  + (y * buffer.stride), buffer.pixel_format};
+    }
+
+    bool operator==(pixel_iterator const& rhs)
+    {
+        return rhs.buffer.vaddr == buffer.vaddr &&
+               rhs.x == x &&
+               rhs.y == y;
+    }
+
+    bool operator!=(pixel_iterator const& rhs)
+    {
+        return !(*this == rhs);
+    }
+
+private:
+    int x, y;
+    MirGraphicsRegion const buffer;
+};
+
+pixel_iterator begin(MirGraphicsRegion const& region)
+{
+    return pixel_iterator(region);
+}
+
+pixel_iterator end(MirGraphicsRegion const& region)
+{
+    return pixel_iterator{region, 0, region.height};
+}
+
+void fill_stream_with(MirBufferStream* stream, int r, int g, int b, int a)
+{
+    MirGraphicsRegion buffer;
+    mir_buffer_stream_get_graphics_region(stream, &buffer);
+
+    for (auto pixel : buffer)
+    {
+        pixel.write(r, g, b, a);
+    }
+}
+
+void bounce_position(int& position, int& delta, int min, int max)
+{
+    if (position <= min || position >= max)
+    {
+        delta = -delta;
+    }
+    position += delta;
+}
+
+int main(int /*argc*/, char* /*argv*/[])
+{
+    char const* socket = nullptr;
+    int const width = 200;
+    int const height = 200;
+    int baseColour = 255, dbase = 1;
+    unsigned int nformats{0};
+    MirPixelFormat pixel_format;
+
+    me::Connection connection{socket, "MirRenderSurface example"};
+    auto render_surface = mir_connection_create_render_surface(connection);
+
+    if (!mir_render_surface_is_valid(render_surface))
+        throw std::runtime_error(std::string("could not create render surface"));
+
+    mir_connection_get_available_surface_formats(connection, &pixel_format, 1, &nformats);
+    if (nformats == 0)
+        throw std::runtime_error("no pixel formats for buffer stream");
+
+    auto spec = mir_connection_create_spec_for_normal_surface(
+        connection,
+        width, height,
+        pixel_format);
+
+    mir_surface_spec_set_name(spec, "Stream");
+    mir_surface_spec_set_buffer_usage(spec, mir_buffer_usage_software);
+
+    auto buffer_stream = mir_render_surface_create_buffer_stream_sync(
+        render_surface,
+        width, height,
+        pixel_format,
+        mir_buffer_usage_software);
+
+    mir_surface_spec_add_render_surface(spec, width, height, 0, 0, render_surface);
+
+    auto surface = mir_surface_create_sync(spec);
+    mir_surface_spec_release(spec);
+
+    fill_stream_with(buffer_stream, 255, 0, 0, 128);
+    mir_buffer_stream_swap_buffers_sync(buffer_stream);
+
+    sigset_t halt_signals;
+    sigemptyset(&halt_signals);
+    sigaddset(&halt_signals, SIGTERM);
+    sigaddset(&halt_signals, SIGQUIT);
+    sigaddset(&halt_signals, SIGINT);
+
+    sigprocmask(SIG_BLOCK, &halt_signals, nullptr);
+    int const signal_watch{signalfd(-1, &halt_signals, SFD_CLOEXEC)};
+
+    pollfd signal_poll{
+        signal_watch,
+        POLLIN | POLLERR,
+        0
+    };
+
+    while (poll(&signal_poll, 1, 0) <= 0)
+    {
+        bounce_position(baseColour, dbase, 128, 255);
+
+        fill_stream_with(buffer_stream, baseColour, 0, 0, 128);
+
+        mir_buffer_stream_swap_buffers_sync(buffer_stream);
+    }
+
+    mir_buffer_stream_release_sync(buffer_stream);
+    mir_render_surface_release(render_surface);
+    mir_surface_release_sync(surface);
+    close(signal_watch);
+
+    return 0;
+}

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2016-08-08 03:22:02 +0000
+++ src/client/CMakeLists.txt	2016-08-12 21:54:21 +0000
@@ -83,6 +83,8 @@
   presentation_chain.cpp
   mir_presentation_chain_api.cpp
   mir_buffer_api.cpp
+  mir_render_surface_api.cpp
+  render_surface.cpp
   display_configuration_api.cpp
   protobuf_to_native_buffer.cpp
   buffer_factory.cpp

=== modified file 'src/client/buffer_stream.cpp'
--- src/client/buffer_stream.cpp	2016-08-01 07:24:32 +0000
+++ src/client/buffer_stream.cpp	2016-08-12 21:54:21 +0000
@@ -419,6 +419,7 @@
 
 mcl::BufferStream::BufferStream(
     MirConnection* connection,
+    MirRenderSurface* render_surface,
     std::shared_ptr<MirWaitHandle> creation_wait_handle,
     mclr::DisplayServer& server,
     std::shared_ptr<mcl::ClientPlatform> const& client_platform,
@@ -430,6 +431,7 @@
     geom::Size ideal_size,
     size_t nbuffers)
     : connection_(connection),
+      render_surface_(render_surface),
       display_server(server),
       client_platform(client_platform),
       protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>(a_protobuf_bs)},
@@ -518,6 +520,7 @@
 
 mcl::BufferStream::BufferStream(
     MirConnection* connection,
+    MirRenderSurface* render_surface,
     std::shared_ptr<MirWaitHandle> creation_wait_handle,
     mclr::DisplayServer& server,
     std::shared_ptr<mcl::ClientPlatform> const& client_platform,
@@ -527,6 +530,7 @@
     std::shared_ptr<mcl::PerfReport> const& perf_report,
     size_t nbuffers)
     : connection_(connection),
+      render_surface_(render_surface),
       display_server(server),
       client_platform(client_platform),
       protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>()},
@@ -782,3 +786,8 @@
 {
     return connection_;
 }
+
+MirRenderSurface* mcl::BufferStream::render_surface() const
+{
+    return render_surface_;
+}

=== modified file 'src/client/buffer_stream.h'
--- src/client/buffer_stream.h	2016-06-02 05:33:50 +0000
+++ src/client/buffer_stream.h	2016-08-12 21:54:21 +0000
@@ -73,6 +73,7 @@
 public:
     BufferStream(
         MirConnection* connection,
+        MirRenderSurface* render_surface,
         std::shared_ptr<MirWaitHandle> creation_wait_handle,
         mir::client::rpc::DisplayServer& server,
         std::shared_ptr<ClientPlatform> const& native_window_factory,
@@ -85,6 +86,7 @@
     // For surfaceless buffer streams
     BufferStream(
         MirConnection* connection,
+        MirRenderSurface* render_surface,
         std::shared_ptr<MirWaitHandle> creation_wait_handle,
         mir::client::rpc::DisplayServer& server,
         std::shared_ptr<ClientPlatform> const& native_window_factory,
@@ -127,6 +129,7 @@
     MirWaitHandle* set_scale(float scale) override;
     char const* get_error_message() const override;
     MirConnection* connection() const override;
+    MirRenderSurface* render_surface() const override;
 
 protected:
     BufferStream(BufferStream const&) = delete;
@@ -144,6 +147,7 @@
     mutable std::mutex mutex; // Protects all members of *this
 
     MirConnection* connection_;
+    MirRenderSurface* render_surface_;
     mir::client::rpc::DisplayServer& display_server;
     std::shared_ptr<ClientPlatform> const client_platform;
     std::unique_ptr<mir::protobuf::BufferStream> protobuf_bs;

=== modified file 'src/client/client_buffer_stream.h'
--- src/client/client_buffer_stream.h	2016-06-02 05:33:50 +0000
+++ src/client/client_buffer_stream.h	2016-08-12 21:54:21 +0000
@@ -23,6 +23,7 @@
 #include "mir/geometry/size.h"
 
 #include "mir_toolkit/client_types.h"
+#include "mir_toolkit/client_types_nbs.h"
 #include "mir_toolkit/mir_native_buffer.h"
 #include "mir_wait_handle.h"
 
@@ -91,6 +92,7 @@
     virtual MirWaitHandle* set_scale(float) = 0;
     virtual char const* get_error_message() const = 0;
     virtual MirConnection* connection() const = 0;
+    virtual MirRenderSurface* render_surface() const = 0;
 
     virtual void buffer_available(mir::protobuf::Buffer const& buffer) = 0;
     virtual void buffer_unavailable() = 0;

=== modified file 'src/client/connection_surface_map.h'
--- src/client/connection_surface_map.h	2016-06-06 11:51:31 +0000
+++ src/client/connection_surface_map.h	2016-08-12 21:54:21 +0000
@@ -23,14 +23,15 @@
 
 #include <shared_mutex>
 #include <unordered_map>
+#include <set>
 
 class MirPresentationChain;
+class MirRenderSurface;
 namespace mir
 {
 namespace client
 {
 class MirBuffer;
-class PresentationChain;
 class ConnectionSurfaceMap : public SurfaceMap
 {
 public:
@@ -50,6 +51,9 @@
     void erase(int buffer_id) override;
     std::shared_ptr<MirBuffer> buffer(int buffer_id) const override;
 
+    void insert(void* render_surface_key, std::shared_ptr<MirRenderSurface> const& render_surface);
+    void erase(void* render_surface_key);
+
 private:
     std::shared_timed_mutex mutable guard;
     std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surfaces;
@@ -58,6 +62,7 @@
     std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirPresentationChain>> chains;
     std::shared_timed_mutex mutable buffer_guard;
     std::unordered_map<int, std::shared_ptr<MirBuffer>> buffers;
+    std::unordered_map<void*, std::shared_ptr<MirRenderSurface>> render_surfaces;
 };
 
 }

=== modified file 'src/client/error_stream.cpp'
--- src/client/error_stream.cpp	2016-01-18 15:24:00 +0000
+++ src/client/error_stream.cpp	2016-08-12 21:54:21 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "error_stream.h"
+#include "render_surface.h"
 
 namespace mcl = mir::client;
 
@@ -30,6 +31,16 @@
 {
 }
 
+mcl::ErrorStream::ErrorStream(
+    std::string const& error_msg, RenderSurface* render_surface,
+    mir::frontend::BufferStreamId id, std::shared_ptr<MirWaitHandle> const& wh) :
+    error(error_msg),
+    connection_(render_surface->connection()),
+    id(id),
+    wh(wh)
+{
+}
+
 char const* mcl::ErrorStream::get_error_message() const
 {
     return error.c_str();
@@ -45,6 +56,11 @@
     return connection_;
 }
 
+MirRenderSurface* mcl::ErrorStream::render_surface() const
+{
+    return nullptr;
+}
+
 mir::frontend::BufferStreamId mcl::ErrorStream::rpc_id() const
 {
     return id;

=== modified file 'src/client/error_stream.h'
--- src/client/error_stream.h	2016-01-18 15:24:00 +0000
+++ src/client/error_stream.h	2016-08-12 21:54:21 +0000
@@ -24,6 +24,9 @@
 {
 namespace client
 {
+
+class RenderSurface;
+
 class ErrorStream : public ClientBufferStream
 {
 public:
@@ -31,6 +34,10 @@
         std::string const& error_msg, MirConnection* conn,
         frontend::BufferStreamId id, std::shared_ptr<MirWaitHandle> const& wh);
 
+    ErrorStream(
+        std::string const& error_msg, RenderSurface* render_surface,
+        frontend::BufferStreamId id, std::shared_ptr<MirWaitHandle> const& wh);
+
     MirWaitHandle* get_create_wait_handle();
     MirSurfaceParameters get_parameters() const;
     std::shared_ptr<ClientBuffer> get_current_buffer();
@@ -51,6 +58,7 @@
     MirWaitHandle* set_scale(float);
     char const* get_error_message() const;
     MirConnection* connection() const;
+    MirRenderSurface* render_surface() const;
 private:
     std::string const error;
     MirConnection* const connection_;

=== modified file 'src/client/mir_buffer_stream_api.cpp'
--- src/client/mir_buffer_stream_api.cpp	2016-05-03 06:55:25 +0000
+++ src/client/mir_buffer_stream_api.cpp	2016-08-12 21:54:21 +0000
@@ -22,6 +22,7 @@
 #include "mir_surface.h"
 #include "mir_connection.h"
 #include "buffer_stream.h"
+#include "mir_render_surface.h"
 
 #include "mir_toolkit/mir_buffer.h"
 #include "mir/client_buffer.h"
@@ -88,7 +89,11 @@
 {
     auto bs = reinterpret_cast<mcl::ClientBufferStream*>(buffer_stream);
     auto connection = bs->connection();
-    return connection->release_buffer_stream(bs, callback, context);
+    auto rs = reinterpret_cast<MirRenderSurface*>(bs->render_surface());
+    if (rs)
+        return rs->release_buffer_stream(bs, callback, context);
+    else
+        return connection->release_buffer_stream(bs, callback, context);
 }
 
 void mir_buffer_stream_release_sync(MirBufferStream *buffer_stream)

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2016-06-28 12:18:18 +0000
+++ src/client/mir_connection.cpp	2016-08-12 21:54:21 +0000
@@ -37,6 +37,7 @@
 #include "screencast_stream.h"
 #include "perf_report.h"
 #include "presentation_chain.h"
+#include "render_surface.h"
 #include "error_chain.h"
 #include "logging/perf_report.h"
 #include "lttng/perf_report.h"
@@ -383,7 +384,7 @@
         try
         {
             default_stream = std::make_shared<mcl::BufferStream>(
-                this, request->wh, server, platform, surface_map, buffer_factory,
+                this, nullptr, request->wh, server, platform, surface_map, buffer_factory,
                 surface_proto->buffer_stream(), make_perf_report(logger), name,
                 mir::geometry::Size{surface_proto->width(), surface_proto->height()}, nbuffers);
             surface_map->insert(default_stream->rpc_id(), default_stream);
@@ -404,6 +405,8 @@
     std::shared_ptr<MirSurface> surf {nullptr};
     if (surface_proto->has_error() || !surface_proto->has_id())
     {
+        printf("ERROR: creating surface\n");
+
         std::string reason;
         if (surface_proto->has_error())
             reason += surface_proto->error();
@@ -417,9 +420,18 @@
     }
     else
     {
+        printf("created surface\n");
         surf = std::make_shared<MirSurface>(
             this, server, &debug, default_stream, input_platform, spec, *surface_proto, request->wh);
         surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
+        printf("created surface, setting into render surfaces\n");
+        if (spec.render_surfaces.is_set())
+        {
+            for (auto& rs_it : spec.render_surfaces.value())
+            {
+                rs_it->set_container(reinterpret_cast<MirSurface*>(surf.get()));
+            }
+        }
     }
 
     callback(surf.get(), context);
@@ -822,7 +834,7 @@
     try
     {
         auto stream = std::make_shared<mcl::BufferStream>(
-            this, request->wh, server, platform, surface_map, buffer_factory,
+            this, nullptr, request->wh, server, platform, surface_map, buffer_factory,
             *protobuf_bs, make_perf_report(logger), std::string{},
             mir::geometry::Size{request->parameters.width(), request->parameters.height()}, nbuffers);
         surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), stream);
@@ -1252,3 +1264,18 @@
     released_buffer->set_buffer_id(buffer->rpc_id());
     server.release_buffers(&request, ignored.get(), gp::NewCallback(ignore));
 }
+
+MirRenderSurface* MirConnection::create_render_surface()
+{
+    std::shared_ptr<MirRenderSurface> rs {nullptr};
+
+    rs = std::make_shared<mcl::RenderSurface>(
+        this, server, surface_map, nbuffers, platform, buffer_factory, logger);
+    surface_map->insert(static_cast<void*>(rs.get()), rs);
+    return rs.get();
+}
+
+void MirConnection::release_render_surface(MirRenderSurface* render_surface)
+{
+    surface_map->erase(static_cast<void*>(render_surface));
+}

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2016-06-28 12:18:18 +0000
+++ src/client/mir_connection.h	2016-08-12 21:54:21 +0000
@@ -200,6 +200,8 @@
         mir_buffer_callback callback, void* context);
     void release_buffer(mir::client::MirBuffer* buffer);
 
+    MirRenderSurface* create_render_surface();
+    void release_render_surface(MirRenderSurface* render_surface);
 private:
     //google cant have callbacks with more than 2 args
     struct SurfaceCreationRequest

=== added file 'src/client/mir_render_surface.h'
--- src/client/mir_render_surface.h	1970-01-01 00:00:00 +0000
+++ src/client/mir_render_surface.h	2016-08-12 21:54:21 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2016 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:
+ *   Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_MIR_RENDER_SURFACE_H
+#define MIR_CLIENT_MIR_RENDER_SURFACE_H
+
+#include "mir_toolkit/mir_render_surface.h"
+
+namespace mir
+{
+namespace client
+{
+class ClientBufferStream;
+}
+}
+
+class MirRenderSurface
+{
+public:
+    virtual ~MirRenderSurface() = default;
+    virtual MirConnection* connection() const = 0;
+    virtual MirWaitHandle* create_client_buffer_stream(
+        int width, int height,
+        MirPixelFormat format,
+        MirBufferUsage buffer_usage,
+        mir_buffer_stream_callback callback,
+        void* context) = 0;
+    virtual MirWaitHandle* release_buffer_stream(
+        mir::client::ClientBufferStream* stream,
+        mir_buffer_stream_callback callback,
+        void* context) = 0;
+    virtual int stream_id() = 0;
+    virtual MirSurface* container() = 0;
+    virtual MirEGLNativeWindowType egl_native_window() = 0;
+
+protected:
+    MirRenderSurface(MirRenderSurface const&) = delete;
+    MirRenderSurface& operator=(MirRenderSurface const&) = delete;
+    MirRenderSurface() = default;
+};
+
+#endif /* MIR_CLIENT_MIR_RENDER_SURFACE_H */

=== added file 'src/client/mir_render_surface_api.cpp'
--- src/client/mir_render_surface_api.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_render_surface_api.cpp	2016-08-12 21:54:21 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2016 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: Cemil Azizoglu <[e-mail]>
+ */
+
+#include "mir_connection.h"
+#include "render_surface.h"
+#include "mir/uncaught.h"
+#include "mir/require.h"
+
+namespace mcl = mir::client;
+
+namespace
+{
+// assign_result is compatible with all 2-parameter callbacks
+void assign_result(void* result, void** context)
+{
+    if (context)
+        *context = result;
+}
+}
+
+MirRenderSurface* mir_connection_create_render_surface(
+    MirConnection* connection)
+try
+{
+    mir::require(connection);
+    return connection->create_render_surface();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}
+
+bool mir_render_surface_is_valid(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    return true;
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return false;
+}
+
+void mir_render_surface_release(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    render_surface->connection()->release_render_surface(render_surface);
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+}
+
+MirBufferStream* mir_render_surface_create_buffer_stream_sync(
+    MirRenderSurface* render_surface,
+    int width, int height,
+    MirPixelFormat format,
+    MirBufferUsage buffer_usage)
+try
+{
+    mir::require(render_surface);
+    MirBufferStream* stream = nullptr;
+    auto rs = reinterpret_cast<mcl::RenderSurface*>(render_surface);
+
+    auto wh = rs->create_client_buffer_stream(
+        width,
+        height,
+        format,
+        buffer_usage,
+        reinterpret_cast<mir_buffer_stream_callback>(assign_result),
+        &stream);
+    wh->wait_for_all();
+    return stream;
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}
+
+MirConnection* mir_render_surface_connection(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+    return render_surface->connection();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}
+
+MirSurface* mir_render_surface_container(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+
+    return render_surface->container();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}
+
+MirEGLNativeWindowType mir_render_surface_egl_native_window(
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(render_surface);
+
+    return render_surface->egl_native_window();
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+    return nullptr;
+}

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2016-08-12 12:57:50 +0000
+++ src/client/mir_surface.cpp	2016-08-12 21:54:21 +0000
@@ -526,6 +526,7 @@
 MirWaitHandle* MirSurface::modify(MirSurfaceSpec const& spec)
 {
     mp::SurfaceModifications mods;
+    printf("modify\n");
 
     {
         std::unique_lock<decltype(mutex)> lock(mutex);
@@ -629,6 +630,7 @@
             new_shape->set_height(rect.height);
         }
     }
+    printf("modify2\n");
 
     modify_wait_handle.expect_result();
     server->modify_surface(&mods, modify_result.get(),

=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2016-06-09 00:38:26 +0000
+++ src/client/mir_surface.h	2016-08-12 21:54:21 +0000
@@ -71,6 +71,7 @@
 class ClientBuffer;
 class ClientBufferStream;
 class ClientBufferStreamFactory;
+class RenderSurface;
 
 struct MemoryRegion;
 }
@@ -131,6 +132,7 @@
     };
     mir::optional_value<EventHandler> event_handler;
     mir::optional_value<MirShellChrome> shell_chrome;
+    mir::optional_value<std::vector<mir::client::RenderSurface*>> render_surfaces;
 };
 
 struct MirPersistentId
@@ -252,4 +254,4 @@
 
 };
 
-#endif /* MIR_CLIENT_PRIVATE_MIR_WAIT_HANDLE_H_ */
+#endif /* MIR_CLIENT_MIR_SURFACE_H_ */

=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2016-07-18 10:11:34 +0000
+++ src/client/mir_surface_api.cpp	2016-08-12 21:54:21 +0000
@@ -20,12 +20,12 @@
 
 #include "mir_toolkit/mir_surface.h"
 #include "mir_toolkit/mir_wait.h"
-#include "mir_toolkit/mir_presentation_chain.h"
 #include "mir/require.h"
 
 #include "mir_connection.h"
 #include "mir_surface.h"
 #include "presentation_chain.h"
+#include "render_surface.h"
 #include "error_connections.h"
 #include "mir/uncaught.h"
 
@@ -558,6 +558,7 @@
 void mir_surface_apply_spec(MirSurface* surface, MirSurfaceSpec* spec)
 try
 {
+    printf("setting into render surfaces\n");
     mir::require(mir_surface_is_valid(surface));
     mir::require(spec);
 
@@ -632,6 +633,44 @@
     MIR_LOG_UNCAUGHT_EXCEPTION(ex);
 }
 
+void mir_surface_spec_add_render_surface(
+    MirSurfaceSpec* spec,
+    int /*scaled_width*/, int /*scaled_height*/,
+    int displacement_x, int displacement_y,
+    MirRenderSurface* render_surface)
+try
+{
+    mir::require(spec && render_surface);
+    auto rs = reinterpret_cast<mcl::RenderSurface*>(render_surface);
+    auto id = rs->stream_id();
+
+    if (id >= 0)
+    {
+        printf("stream_id = %d\n", id);
+        ContentInfo info{{displacement_x, displacement_y}, id, {}};
+
+        if (spec->streams.is_set())
+            spec->streams.value().push_back(info);
+        else
+            spec->streams = std::vector<ContentInfo>{info};
+    }
+
+    if (spec->render_surfaces.is_set())
+    {
+        spec->render_surfaces.value().push_back(rs);
+        printf("render_surface is set\n");
+    }
+    else
+    {
+        spec->render_surfaces = std::vector<mcl::RenderSurface*>{rs};
+        printf("render_surface is NOT set\n");
+    }
+}
+catch (std::exception const& ex)
+{
+    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+}
+
 void mir_surface_spec_set_input_shape(MirSurfaceSpec *spec, MirRectangle const* rectangles,
                                       size_t n_rects)
 try

=== added file 'src/client/render_surface.cpp'
--- src/client/render_surface.cpp	1970-01-01 00:00:00 +0000
+++ src/client/render_surface.cpp	2016-08-12 21:54:21 +0000
@@ -0,0 +1,278 @@
+/*
+ * Copyright © 2016 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:
+ *   Cemil Azizoglu <[e-mail]>
+ */
+
+#include "render_surface.h"
+#include "mir_wait_handle.h"
+#include "rpc/mir_display_server.h"
+#include "connection_surface_map.h"
+#include "buffer_stream.h"
+#include "error_stream.h"
+#include "perf_report.h"
+#include "logging/perf_report.h"
+#include "lttng/perf_report.h"
+#include "make_protobuf_object.h"
+#include "mir_toolkit/mir_surface.h"
+
+#include <algorithm>
+#include <unistd.h>
+#include <boost/exception/diagnostic_information.hpp>
+
+namespace mcl = mir::client;
+namespace mclr = mcl::rpc;
+namespace mp = mir::protobuf;
+namespace gp = google::protobuf;
+namespace mf = mir::frontend;
+namespace ml = mir::logging;
+
+namespace
+{
+void assign_result(void* result, void** context)
+{
+    if (context)
+        *context = result;
+}
+
+std::shared_ptr<mcl::PerfReport>
+make_perf_report(std::shared_ptr<ml::Logger> const& logger)
+{
+    // TODO: It seems strange that this directly uses getenv
+    const char* report_target = getenv("MIR_CLIENT_PERF_REPORT");
+    if (report_target && !strcmp(report_target, "log"))
+    {
+        return std::make_shared<mcl::logging::PerfReport>(logger);
+    }
+    else if (report_target && !strcmp(report_target, "lttng"))
+    {
+        return std::make_shared<mcl::lttng::PerfReport>();
+    }
+    else
+    {
+        return std::make_shared<mcl::NullPerfReport>();
+    }
+}
+}
+
+mcl::RenderSurface::RenderSurface(
+    MirConnection* const connection,
+    mclr::DisplayServer& display_server,
+    std::shared_ptr<ConnectionSurfaceMap> connection_surface_map,
+    int num_buffers,
+    std::shared_ptr<ClientPlatform> client_platform,
+    std::shared_ptr<AsyncBufferFactory> async_buffer_factory,
+    std::shared_ptr<ml::Logger> mir_logger) :
+        connection_(connection),
+        server(display_server),
+        surface_map(connection_surface_map),
+        nbuffers(num_buffers),
+        platform(client_platform),
+        buffer_factory(async_buffer_factory),
+        logger(mir_logger),
+        void_response(mcl::make_protobuf_object<mp::Void>()),
+        container_(nullptr)
+{
+}
+
+MirConnection* mcl::RenderSurface::connection() const
+{
+    return connection_;
+}
+
+MirWaitHandle* mcl::RenderSurface::create_client_buffer_stream(
+    int width, int height,
+    MirPixelFormat format,
+    MirBufferUsage buffer_usage,
+    mir_buffer_stream_callback callback,
+    void* context)
+{
+    mp::BufferStreamParameters params;
+    params.set_width(width);
+    params.set_height(height);
+    params.set_pixel_format(format);
+    params.set_buffer_usage(buffer_usage);
+
+    auto request = std::make_shared<StreamCreationRequest>(callback, context, params);
+    request->wh->expect_result();
+
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        stream_requests.push_back(request);
+    }
+
+    try
+    {
+        server.create_buffer_stream(&params, request->response.get(),
+            gp::NewCallback(this, &mcl::RenderSurface::stream_created, request.get()));
+    } catch (std::exception& e)
+    {
+        //if this throws, our socket code will run the closure, which will make an error object.
+        //its nicer to return a stream with an error message, so just ignore the exception.
+    }
+
+    return request->wh.get();
+}
+
+mf::SurfaceId mcl::RenderSurface::next_error_id(std::unique_lock<std::mutex> const&)
+{
+    return mf::SurfaceId{stream_error_id--};
+}
+
+void mcl::RenderSurface::stream_error(std::string const& error_msg, std::shared_ptr<StreamCreationRequest> const& request)
+{
+    std::unique_lock<decltype(mutex)> lock(mutex);
+    mf::BufferStreamId id(next_error_id(lock).as_value());
+    auto stream = std::make_shared<mcl::ErrorStream>(error_msg, this, id, request->wh);
+    surface_map->insert(id, stream);
+
+    if (request->callback)
+    {
+        request->callback(reinterpret_cast<MirBufferStream*>(dynamic_cast<mcl::ClientBufferStream*>(stream.get())), request->context);
+    }
+    request->wh->result_received();
+}
+
+void mcl::RenderSurface::stream_created(StreamCreationRequest* request_raw)
+{
+    std::shared_ptr<StreamCreationRequest> request {nullptr};
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        auto stream_it = std::find_if(stream_requests.begin(), stream_requests.end(),
+            [&request_raw] (std::shared_ptr<StreamCreationRequest> const& req)
+            { return req.get() == request_raw; });
+        if (stream_it == stream_requests.end())
+            return;
+        request = *stream_it;
+        stream_requests.erase(stream_it);
+    }
+    auto& protobuf_bs = request->response;
+
+    if (!protobuf_bs->has_id())
+    {
+        if (!protobuf_bs->has_error())
+            protobuf_bs->set_error("no ID in response (disconnected?)");
+    }
+
+    if (protobuf_bs->has_error())
+    {
+        for (int i = 0; i < protobuf_bs->buffer().fd_size(); i++)
+            ::close(protobuf_bs->buffer().fd(i));
+        stream_error(
+            std::string{"Error processing buffer stream response: "} + protobuf_bs->error(),
+            request);
+        return;
+    }
+
+    try
+    {
+        auto stream = std::make_shared<mcl::BufferStream>(
+            connection(), this, request->wh, server, platform, surface_map, buffer_factory,
+            *protobuf_bs, make_perf_report(logger), std::string{},
+            mir::geometry::Size{request->parameters.width(), request->parameters.height()}, nbuffers);
+        id = protobuf_bs->id().value();
+        surface_map->insert(mf::BufferStreamId(id), stream);
+
+        if (request->callback)
+            request->callback(reinterpret_cast<MirBufferStream*>(dynamic_cast<mcl::ClientBufferStream*>(stream.get())), request->context);
+        request->wh->result_received();
+    }
+    catch (std::exception const& error)
+    {
+        for (int i = 0; i < protobuf_bs->buffer().fd_size(); i++)
+            ::close(protobuf_bs->buffer().fd(i));
+
+        stream_error(
+            std::string{"Error processing buffer stream creating response:"} + boost::diagnostic_information(error),
+            request);
+    }
+}
+
+int mcl::RenderSurface::stream_id()
+{
+    return id;
+}
+
+struct mcl::RenderSurface::StreamRelease
+{
+    ClientBufferStream* stream;
+    MirWaitHandle* handle;
+    mir_buffer_stream_callback callback;
+    void* context;
+    int rpc_id;
+};
+
+MirWaitHandle* mcl::RenderSurface::release_buffer_stream(
+    ClientBufferStream* stream,
+    mir_buffer_stream_callback callback,
+    void* context)
+{
+    auto new_wait_handle = new MirWaitHandle;
+
+    StreamRelease stream_release{stream, new_wait_handle, callback, context, stream->rpc_id().as_value() };
+
+    mp::BufferStreamId buffer_stream_id;
+    buffer_stream_id.set_value(stream->rpc_id().as_value());
+
+    {
+        std::lock_guard<decltype(release_wait_handle_guard)> rel_lock(release_wait_handle_guard);
+        release_wait_handles.push_back(new_wait_handle);
+    }
+
+    new_wait_handle->expect_result();
+    server.release_buffer_stream(
+        &buffer_stream_id, void_response.get(),
+        google::protobuf::NewCallback(this, &RenderSurface::released, stream_release));
+    return new_wait_handle;
+}
+
+void mcl::RenderSurface::released(StreamRelease data)
+{
+    if (data.callback)
+        data.callback(reinterpret_cast<MirBufferStream*>(data.stream), data.context);
+    if (data.handle)
+        data.handle->result_received();
+    surface_map->erase(mf::BufferStreamId(data.rpc_id));
+}
+
+void mcl::RenderSurface::set_container(MirSurface* const surface)
+{
+    container_ = surface;
+}
+
+MirSurface* mcl::RenderSurface::container()
+{
+    return container_;
+}
+
+MirEGLNativeWindowType mcl::RenderSurface::egl_native_window()
+{
+    MirBufferStream* stream = nullptr;
+    auto wh = create_client_buffer_stream(
+        100,
+        100,
+        mir_pixel_format_argb_8888,
+        mir_buffer_usage_hardware,
+        reinterpret_cast<mir_buffer_stream_callback>(assign_result),
+        &stream);
+    wh->wait_for_all();
+    auto spec = mir_connection_create_spec_for_changes(connection_);
+    mir_surface_spec_add_render_surface(spec, 100, 100, 0, 0, this);
+    mir_surface_apply_spec(container_, spec);
+    mir_surface_spec_release(spec);
+    mcl::ClientBufferStream *bs = reinterpret_cast<mcl::ClientBufferStream*>(stream);
+    return reinterpret_cast<MirEGLNativeWindowType>(bs->egl_native_window());
+}

=== added file 'src/client/render_surface.h'
--- src/client/render_surface.h	1970-01-01 00:00:00 +0000
+++ src/client/render_surface.h	2016-08-12 21:54:21 +0000
@@ -0,0 +1,128 @@
+/*
+ * Copyright © 2016 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:
+ *   Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_RENDER_SURFACE_H
+#define MIR_CLIENT_RENDER_SURFACE_H
+
+#include "mir_render_surface.h"
+#include "mir_toolkit/mir_render_surface.h"
+#include "mir_toolkit/client_types.h"
+#include "mir_protobuf.pb.h"
+#include "mir/frontend/surface_id.h"
+#include <mutex>
+#include <memory>
+
+namespace mir
+{
+
+namespace protobuf
+{
+class BufferStream;
+}
+
+namespace logging
+{
+class Logger;
+}
+
+namespace client
+{
+
+class ConnectionSurfaceMap;
+class ClientPlatform;
+class AsyncBufferFactory;
+
+namespace rpc
+{
+class DisplayServer;
+}
+
+class RenderSurface : public MirRenderSurface
+{
+public:
+    RenderSurface(MirConnection* const connection,
+                  rpc::DisplayServer& display_server,
+                  std::shared_ptr<ConnectionSurfaceMap> connection_surface_map,
+                  int num_buffers,
+                  std::shared_ptr<ClientPlatform> client_platform,
+                  std::shared_ptr<AsyncBufferFactory> async_buffer_factory,
+                  std::shared_ptr<mir::logging::Logger> mir_logger);
+    MirConnection* connection() const override;
+    MirWaitHandle* create_client_buffer_stream(
+        int width, int height,
+        MirPixelFormat format,
+        MirBufferUsage buffer_usage,
+        mir_buffer_stream_callback callback,
+        void *context) override;
+    int stream_id() override;
+    MirWaitHandle* release_buffer_stream(
+        ClientBufferStream* stream,
+        mir_buffer_stream_callback callback,
+        void* context) override;
+    void set_container(MirSurface* const surface);
+    MirSurface* container() override;
+    MirEGLNativeWindowType egl_native_window() override;
+
+
+private:
+    MirConnection* const connection_;
+    rpc::DisplayServer& server;
+    std::shared_ptr<ConnectionSurfaceMap> surface_map;
+    int const nbuffers;
+    std::shared_ptr<ClientPlatform> platform;
+    std::shared_ptr<AsyncBufferFactory> buffer_factory;
+    std::shared_ptr<mir::logging::Logger> const logger;
+    std::unique_ptr<mir::protobuf::Void> void_response;
+    MirSurface* container_;
+
+    struct StreamCreationRequest
+    {
+        StreamCreationRequest(
+            mir_buffer_stream_callback cb, void* context, protobuf::BufferStreamParameters const& params) :
+                callback(cb),
+                context(context),
+                parameters(params),
+                response(std::make_shared<protobuf::BufferStream>()),
+                wh(std::make_shared<MirWaitHandle>())
+        {
+        }
+        mir_buffer_stream_callback callback;
+        void* context;
+        protobuf::BufferStreamParameters const parameters;
+        std::shared_ptr<protobuf::BufferStream> response;
+        std::shared_ptr<MirWaitHandle> const wh;
+    };
+
+    std::vector<std::shared_ptr<StreamCreationRequest>> stream_requests;
+    void stream_created(StreamCreationRequest* request_raw);
+    void stream_error(std::string const& error_msg, std::shared_ptr<StreamCreationRequest> const& request);
+    struct StreamRelease;
+    void released(StreamRelease);
+    std::mutex release_wait_handle_guard;
+    std::vector<MirWaitHandle*> release_wait_handles;
+
+    frontend::SurfaceId next_error_id(std::unique_lock<std::mutex> const&);
+    int stream_error_id{-1};
+    int id{-1};
+    std::mutex mutex;
+};
+
+}
+}
+#endif /* MIR_CLIENT_RENDER_SURFACE_H */

=== modified file 'src/client/screencast_stream.cpp'
--- src/client/screencast_stream.cpp	2016-06-02 05:33:50 +0000
+++ src/client/screencast_stream.cpp	2016-08-12 21:54:21 +0000
@@ -234,6 +234,11 @@
     return connection_;
 }
 
+MirRenderSurface* mcl::ScreencastStream::render_surface() const
+{
+    return nullptr;
+}
+
 void mcl::ScreencastStream::set_buffer_cache_size(unsigned int)
 {
     BOOST_THROW_EXCEPTION(std::logic_error("Attempt to set cache size on screencast is invalid"));

=== modified file 'src/client/screencast_stream.h'
--- src/client/screencast_stream.h	2016-05-03 06:55:25 +0000
+++ src/client/screencast_stream.h	2016-08-12 21:54:21 +0000
@@ -99,6 +99,7 @@
     MirWaitHandle* set_scale(float scale) override;
     char const* get_error_message() const override;
     MirConnection* connection() const override;
+    MirRenderSurface* render_surface() const override;
 
 private:
     void process_buffer(protobuf::Buffer const& buffer);

=== modified file 'src/client/surface_map.cpp'
--- src/client/surface_map.cpp	2016-06-06 11:51:31 +0000
+++ src/client/surface_map.cpp	2016-08-12 21:54:21 +0000
@@ -129,3 +129,17 @@
     else
         BOOST_THROW_EXCEPTION(std::runtime_error("could not find buffer"));
 }
+
+void mcl::ConnectionSurfaceMap::insert(void* render_surface_key, std::shared_ptr<MirRenderSurface> const& render_surface)
+{
+    std::lock_guard<decltype(guard)> lk(guard);
+    render_surfaces[render_surface_key] = render_surface;
+}
+
+void mcl::ConnectionSurfaceMap::erase(void* render_surface_key)
+{
+    std::lock_guard<decltype(guard)> lk(guard);
+    auto rs_it = render_surfaces.find(render_surface_key);
+    if (rs_it != render_surfaces.end())
+        render_surfaces.erase(rs_it);
+}

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2016-08-09 06:44:52 +0000
+++ src/client/symbols.map	2016-08-12 21:54:21 +0000
@@ -383,6 +383,14 @@
     mir_buffer_get_buffer_usage;
     mir_buffer_is_valid;
     mir_buffer_get_error_message;
+    mir_connection_create_render_surface;
+    mir_render_surface_is_valid;
+    mir_render_surface_release;
+    mir_surface_spec_add_render_surface;
+    mir_render_surface_create_buffer_stream_sync;
+    mir_render_surface_connection;
+    mir_render_surface_container;
+    mir_render_surface_egl_native_window;
   local:
     *;
 } MIR_CLIENT_DETAIL_9v19;

=== modified file 'src/include/client/mir_toolkit/client_types_nbs.h'
--- src/include/client/mir_toolkit/client_types_nbs.h	2016-06-02 05:33:50 +0000
+++ src/include/client/mir_toolkit/client_types_nbs.h	2016-08-12 21:54:21 +0000
@@ -32,6 +32,7 @@
 typedef struct MirPresentationChain MirPresentationChain;
 typedef struct MirBuffer MirBuffer;
 typedef void* MirNativeFence;
+typedef struct MirRenderSurface MirRenderSurface;
 
 typedef void (*mir_buffer_callback)(MirBuffer*, void* context);
 typedef void (*mir_presentation_chain_callback)(MirPresentationChain*, void* context);

=== added file 'src/include/client/mir_toolkit/mir_render_surface.h'
--- src/include/client/mir_toolkit/mir_render_surface.h	1970-01-01 00:00:00 +0000
+++ src/include/client/mir_toolkit/mir_render_surface.h	2016-08-12 21:54:21 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2016 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:
+ *   Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_TOOLKIT_MIR_RENDER_SURFACE_H_
+#define MIR_TOOLKIT_MIR_RENDER_SURFACE_H_
+
+#include <mir_toolkit/client_types_nbs.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+MirRenderSurface* mir_connection_create_render_surface(
+    MirConnection* connection);
+
+bool mir_render_surface_is_valid(
+    MirRenderSurface* render_surface);
+
+void mir_render_surface_release(
+    MirRenderSurface* render_surface);
+
+void mir_surface_spec_add_render_surface(
+    MirSurfaceSpec* spec,
+    int scaled_width, int scaled_height,
+    int displacement_x, int displacement_y,
+    MirRenderSurface* render_surface);
+
+MirBufferStream* mir_render_surface_create_buffer_stream_sync(
+    MirRenderSurface* render_surface,
+    int width, int height,
+    MirPixelFormat format,
+    MirBufferUsage buffer_usage);
+
+MirConnection* mir_render_surface_connection(
+    MirRenderSurface* render_surface);
+
+MirSurface* mir_render_surface_container(
+    MirRenderSurface* render_surface);
+
+MirEGLNativeWindowType mir_render_surface_egl_native_window(
+    MirRenderSurface* render_surface);
+
+#if 0
+MirPresentationChain* mir_render_surface_create_presentation_chain_sync(
+    MirRenderSurface*);
+#endif
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif // MIR_TOOLKIT_MIR_RENDER_SURFACE_H_